Wikipedia

Julia (programming language): Difference between revisions

Browse history interactively
← Previous edit
Content deleted Content added
VisualWikitext
Svaksha (talk | contribs)
423 edits
No edit summary
Tags: Mobile edit Mobile web edit
 
Line 1:
{{Short description|Dynamic programming language}}
{{Use dmy dates|date=October 2015}}
{{Infobox programming language
| name = Julia
| logo = Julia Programming Language Logo.svg
| logo = [[File:Julia (programming language) logo.png|200px|Official Julia logo]]
| logo size = 140px
| paradigm = [[multi-paradigm programming language|multi-paradigm]]: [[procedural programming|procedural]], [[multiple dispatch]], [[functional programming|functional]], [[metaprogramming|meta]]
| screenshot = <!-- filename is enough -->
| year = 2012
| screenshot caption =
| designer = Jeff Bezanson, Stefan Karpinski, Viral B. Shah
| paradigm = [[Multi-paradigm programming language|Multi-paradigm]]: [[multiple dispatch]] (primary paradigm), [[functional programming|functional]], [[array programming|array]], [[procedural programming|procedural]] ([[imperative programming|imperative]]), [[structured programming|structured]], [[reflective programming|reflective]], [[metaprogramming|meta]], [[multistaged programming|multistaged]]<ref>{{Cite web |url=https://medium.com/@acidflask/smoothing-data-with-julia-s-generated-functions-c80e240e05f3#.615wk3dle |title=Smoothing data with Julia's @generated functions |quote=Julia's generated functions are closely related to the multistaged programming (MSP) paradigm popularized by Taha and Sheard, which generalizes the compile time/run time stages of program execution by allowing for multiple stages of delayed code execution. |date=5 November 2015 |access-date=9 December 2015 |archive-date=4 March 2016 |archive-url=https://web.archive.org/web/20160304105339/https://medium.com/@acidflask/smoothing-data-with-julia-s-generated-functions-c80e240e05f3#.615wk3dle |url-status=live }}</ref>
| developer =
| released = {{Start date and age|2012}}<ref name="announcement">{{Cite web
| latest_release_version =
|title = Why We Created Julia
| typing = [[dynamic programming language | dynamic]] with optional [[type signature | type annotations]] and [[type inference]]
|author1 = Jeff Bezanson
| implementations =
|author2 dialects = Stefan = Karpinski
|author3 = Viral Shah
| influenced_by = [[MATLAB]], [[Scheme (programming language) | Scheme]], [[Lisp (programming language) | Lisp]], [[C (programming language) | C]], [[Python (programming language) | Python]], [[Perl (programming language) | Perl]], [[Ruby (programming language) | Ruby]]
|author4 = Alan Edelman
| operating_system = [[Linux]], [[OS X]], [[FreeBSD]], [[Windows (operating system) | Windows]]
| license date = [[MITFebruary License]]2012
| website = [http://www.julialang.orgJulia julialang.org]website
|url = https://julialang.org/blog/2012/02/why-we-created-julia
| file_ext = .jl
|access-date = 7 February 2013
|archive-date = 2 May 2020
|archive-url = https://web.archive.org/web/20200502144010/https://julialang.org/blog/2012/02/why-we-created-julia/
|url-status = live
}}</ref>
| designer = [[Jeff Bezanson (programmer)|Jeff Bezanson]], [[Alan Edelman]], [[Stefan Karpinski]], [[Viral B. Shah]]
| developer = [[Jeff Bezanson (programmer)|Jeff Bezanson]], [[Stefan Karpinski]], [[Viral B. Shah]], and other contributors<ref name="license">{{Cite web
| url = https://github.com/JuliaLang/julia/blob/master/LICENSE.md
| title = LICENSE.md
| date = September 2017
| publisher = [[GitHub]]
| access-date = 20 October 2014
| archive-date = 23 January 2021
| archive-url = https://web.archive.org/web/20210123222058/https://github.com/JuliaLang/julia/blob/master/LICENSE.md
| url-status = live
}}</ref><ref>{{Cite web
| url = https://github.com/JuliaLang/julia/graphs/contributors
| title = Contributors to JuliaLang/julia
| publisher = [[GitHub]]
| access-date = 20 October 2014
| archive-date = 23 January 2021
| archive-url = https://web.archive.org/web/20210123223030/https://github.com/JuliaLang/julia/graphs/contributors
| url-status = live
}}</ref>
| latest_release_version = {{wikidata|property|edit|reference|Q28974961 |P548=Q2804309|P348}}
| latest_release_date = {{nowrap|{{start date and age|{{wikidata|qualifier| Q28974961 |P348|P577}}|df=y}}}}<br /> and 1.10.10<ref>{{Cite web |title=GitHub - JuliaLang/julia at v1.10.9 |url=https://github.com/JuliaLang/julia/tree/v1.10.9 |access-date=2025-03-10 |website=GitHub |language=en}}</ref> ([[long-term support|LTS]]) / {{nowrap|{{start date and age|2025|06|27|df=y}}}}
| latest preview version = 1.12.0-rc1<ref>{{Cite web |title=Backports for 1.12.0-rc1 by KristofferC · Pull Request #58956 · JuliaLang/julia |url=https://github.com/JuliaLang/julia/pull/58956 |access-date=2025-07-12 |website=GitHub |language=en}}</ref><ref>{{Cite web |title=Backports for 1.12.0-beta4 by KristofferC · Pull Request #58369 · JuliaLang/julia |url=https://github.com/JuliaLang/julia/pull/58369 |access-date=2025-05-10 |website=GitHub |language=en}}</ref><ref>{{Cite web |title=GitHub - JuliaLang/julia at v1.12.0-beta3 |url=https://github.com/JuliaLang/julia/tree/v1.12.0-beta3 |access-date=2025-05-12 |website=GitHub |language=en}}</ref>
| latest_preview_date = {{start date and age|2025|07|12|df=y}}. Being worked on: 1.12.0-rc2<ref>{{Cite web |title=Backports for Julia 1.12-rc2 by KristofferC · Pull Request #59006 · JuliaLang/julia |url=https://github.com/JuliaLang/julia/pull/59006 |access-date=2025-07-18 |website=GitHub |language=en}}</ref> and 1.13.0-DEV with daily updates
| typing = [[Dynamic programming language|Dynamic]],<ref name="Engheim">{{Cite web|last=Engheim|first=Erik|date=2017-11-17|title=Dynamically Typed Languages Are Not What You Think|url=https://erik-engheim.medium.com/dynamically-typed-languages-are-not-what-you-think-ac8d1392b803|access-date=2021-01-27|website=Medium|language=en|archive-date=5 March 2021|archive-url=https://web.archive.org/web/20210305194133/https://erik-engheim.medium.com/dynamically-typed-languages-are-not-what-you-think-ac8d1392b803|url-status=live}}</ref> [[type inference|inferred]], [[optional typing|optional]], [[nominal type system|nominative]], [[parametric polymorphism|parametric]], [[strong and weak typing|strong]]<ref name="Engheim" />
| implementations =
| dialects =
| influenced by = {{Flatlist}}
* [[Dylan (programming language)|Dylan]]<ref name="goldilocks">{{Cite web |last1=Stokel-Walker |first1=Chris |title=Julia: The Goldilocks language |url=https://increment.com/programming-languages/goldilocks-language-history-of-julia/ |website=Increment |publisher=Stripe |access-date=23 August 2020 |archive-date=9 November 2020 |archive-url=https://web.archive.org/web/20201109024158/https://increment.com/programming-languages/goldilocks-language-history-of-julia/ |url-status=live }}</ref>
* [[Lisp (programming language)|Lisp]]<ref name="announcement"/><ref name="JuliaCon2016">{{Cite web |url=https://juliacon.org/2016 |title=JuliaCon 2016 |publisher=JuliaCon |quote="He has co-designed the programming language Scheme, which has greatly influenced the design of Julia" |access-date=6 December 2016 |archive-date=4 March 2017 |archive-url=https://web.archive.org/web/20170304010606/http://juliacon.org/2016/ |url-status=live }}</ref>
* [[Lua (programming language)|Lua]]<ref name="Introduction">{{Cite web|url=https://docs.julialang.org/en/v1/|title=<!--Chapter: Introduction under --> Home · The Julia Language|website=docs.julialang.org|language=en|access-date=2018-08-15|archive-date=11 January 2021|archive-url=https://web.archive.org/web/20210111031656/https://docs.julialang.org/en/v1/|url-status=live}}</ref>
* [[Wolfram Language|Mathematica]]<ref>{{Cite web |url=https://fatiherikli.github.io/programming-language-network/#language:Julia |title=Programming Language Network |publisher=GitHub |access-date=6 December 2016 |archive-date=20 December 2020 |archive-url=https://web.archive.org/web/20201220131729/http://fatiherikli.github.io/programming-language-network/#language:Julia }}</ref><ref>{{Cite web|title=What Should We Call the Language of Mathematica?—Stephen Wolfram Writings|url=https://writings.stephenwolfram.com/2013/02/what-should-we-call-the-language-of-mathematica/|access-date=2021-06-24|website=writings.stephenwolfram.com|date=12 February 2013 |language=en|archive-date=4 September 2024|archive-url=https://web.archive.org/web/20240904035044/https://writings.stephenwolfram.com/2013/02/what-should-we-call-the-language-of-mathematica/|url-status=live |last1=Wolfram |first1=Stephen }}</ref>
* [[MATLAB]]<ref name="announcement"/>
* [[Perl]]<ref name="Introduction"/>
* [[Python (programming language)|Python]]<ref name="Introduction"/>
* [[R (programming language)|R]]<ref name="announcement"/>
* [[Ruby (programming language)|Ruby]]<ref name="Introduction"/>
* [[Fortress (programming language)|Fortress]]
{{endflatlist}}
| influenced =
| programming language = Julia, [[C (programming language)|C]],<!-- "Remove when C11 is required for C code" https://github.com/JuliaLang/julia/search?utf8=%E2%9C%93&q=C11&type=
 
"These roughly follows the c11/c++11 memory model [..] The only exception is the GC safepoint and GC state transitions [..] We use the compiler intrinsics to implement a similar API to the c11/c++11" https://github.com/JuliaLang/julia/blob/44f3d7c921cbe50105a54258db2febb65a4b9d44/src/julia_threads.h
--> [[C++]], [[LLVM]],<ref>{{Cite web |title=Building Julia (Detailed) |website=[[GitHub]] |date=September 2017 |url=https://github.com/JuliaLang/julia/blob/master/doc/src/devdocs/build/build.md#required-build-tools-and-external-libraries |access-date=2022-05-16 |archive-date=16 May 2022 |archive-url=https://web.archive.org/web/20220516170342/https://github.com/JuliaLang/julia/blob/master/doc/src/devdocs/build/build.md#required-build-tools-and-external-libraries |url-status=live }}</ref> [[Scheme (programming language)|Scheme]] (<!-- is still used for lowering code (and bootstrapping? only that 1-2 functions, likely Scheme uyse will be elimintaed, i.e. for both; plus -->was used the parser; almost exclusively)
| platform = Tier&nbsp;1: 64- and 32-bit [[Windows 10]]+, [[Linux distro|Linux]], and 64-bit [[macOS]]; [[IA-32]], [[x86-64]], [[Apple silicon]] <small>([[AArch64|ARM64]])</small> Macs; Nvidia GPUs/[[CUDA]] 11.0+ (on Linux; {{nowrap|tier 2}} for Windows)<ref>{{Cite web|title=NVIDIA CUDA ⋅ JuliaGPU|url=https://juliagpu.org/cuda/|access-date=2022-01-17|website=juliagpu.org|quote=we have shown the performance to approach and even sometimes exceed that of CUDA C on a selection of applications from the Rodinia benchmark suite|archive-date=29 January 2022|archive-url=https://web.archive.org/web/20220129013944/https://juliagpu.org/cuda/|url-status=live}}</ref><br /><br /> Tier&nbsp;2: 64-bit [[FreeBSD]] 13.4+, Linux on [[Armv8|64-bit Arm]]; Apple GPUs/Metal on macOS 13+, Intel GPUs/[[OneAPI (compute acceleration)|OneAPI]] 6.2+ and Nvidia GPUs (on Windows)<br /><br /> Tier&nbsp;3: <!-- downgraded to tier 4: 32-bit [[ARM architecture family|Arm]], --> 64-bit [[RISC-V]], 64-bit [[musl]] (e.g. [[Alpine Linux]]); and AMD GPUs/[[ROCm]] 5.3+.
| operating system = [[Linux]], [[macOS]], [[Microsoft Windows|Windows]] 10+ and <!-- no longer just community support for --> [[FreeBSD]]
| license = [[MIT License|MIT]] <!-- (mainly),<ref name="license" /><!- for core language while, by default, "the environment, which consists of the language, user interfaces, and libraries, is under the GPL"; includes [[GNU General Public License|GPL v2]] components by default;<ref>{{Cite web |title=julia/julia.spdx.json |website=[[GitHub]] |date=September 2017 |url=https://github.com/JuliaLang/julia/blob/7b395153e80672f8cdb18f51dd653a85e28b2070/julia.spdx.json |access-date=2022-05-16}}</ref><ref>{{Cite newsgroup|url=https://groups.google.com/forum/#!topic/julia-users/v4OjEK7azBs |title=Non-GPL Julia? |website=Groups.google.com |access-date=2017-05-31}}</ref><!--as some few libraries used by the standard library (that can be excluded) are [[copyleft]]-> a [[makefile]] option omits GPL libraries.<ref>{{Cite web |url=https://github.com/JuliaLang/julia/pull/10870 |title=Introduce USE_GPL_LIBS Makefile flag to build Julia without GPL libraries |website=[[GitHub]] |quote=Note that this commit does not remove GPL utilities such as git and busybox that are included in the Julia binary installers on Mac and Windows.--><!--dropped as of 0.5 then only libgit2--><!-- It allows building from source with no GPL library dependencies.}}</ref> -->
| file ext = .jl
| website = {{Official website|https://JuliaLang.org|name=JuliaLang.org}}
}}
 
'''Julia''' is a [[dynamic programming language|dynamic]] [[general-purpose programming language|general-purpose]] [[programming language]]. As a [[high-level programming language|high-level]] language, distinctive aspects of Julia's design include a type system with [[parametric polymorphism]], the use of [[multiple dispatch]] as a core [[programming paradigm]], [[just-in-time compilation|just-in-time]] (JIT) compilation and a parallel [[tracing garbage collection|garbage collection]] implementation. Notably Julia does not support [[Class (computer programming)|classes]] with [[Encapsulation (computer programming)|encapsulated]] methods but instead relies on the types of all of a function's arguments to determine which method will be called.
'''Julia''' is a [[high-level programming language | high-level]] [[dynamic programming language]] written specifically for high-performance numerical and [[scientific computing]].<ref>{{cite web|title=The Julia Language (Official Website)|url=http://julialang.org/}}</ref> <ref>{{cite web|last=Bryant|first=Avi|title=MATLAB, R, and Julia: Languages for data analysis|url=http://strata.oreilly.com/2012/10/matlab-r-julia-languages-for-data-analysis.html|publisher=O'Reilly Strata|accessdate=7 February 2013}}</ref> <ref>{{cite web|last=Krill|first=Paul|title=New Julia language seeks to be the C for scientists|url=http://www.infoworld.com/d/application-development/new-julia-language-seeks-be-the-c-scientists-190818|publisher=InfoWorld|accessdate=7 February 2013}}</ref> Julia is written in [[C (programming language)| C]] and [[C++]] using the [[LLVM]] compiler framework.<ref>{{cite web|title=Julia: A Fast Dynamic Language for Technical Computing|url=http://julialang.org/images/julia-dynamic-2012-tr.pdf}}</ref> Development of Julia began in 2009 and an open source version was publicized in February 2012.<ref>{{cite web|title=Why We Created Julia|url=http://julialang.org/blog/2012/02/why-we-created-julia/|accessdate=7 February 2013}}</ref> <ref>{{cite web|last=Mark|first=Gibbs|title=Pure and Julia are cool languages worth checking out|url=http://www.networkworld.com/columnists/2013/010913-gearhead.html|work=Network World|accessdate=7 February 2013}}</ref> Unusual aspects of Julia's design are the inclusion of an expressive type system in a fully dynamic language and multiple-dispatch being its core programming paradigm. The most notable aspect of the Julia implementation is its performance, which often comes within a factor of two of fully optimized C code, putting it within the performance realm of compiled languages.
 
By default, Julia is run similarly to scripting languages, using its runtime, and allows for [[read–eval–print loop|interactions]],<ref name="PackageCompiler.jl" /> but Julia programs/[[source code]] can also optionally be sent to users in one ready-to-install/run file, which can be made quickly, not needing anything preinstalled.<ref name=AppBundler.jl /> <!-- controversial on Talk, page, for now commenting out, may move out of lead: Julia programs can also be (separately) compiled to [[binary executable]]s, even allowing no-source-code distribution, and the executables can get much smaller with Julia 1.12. Such compilation is not needed for speed, though it can decrease constant-factor startup cost, since Julia is also compiled when running interactively, but it can help with hiding source code. Features of the language can be separately compiled, so Julia can be used, for example, with its runtime or without it (which allows for smaller executables and libraries but is limited in capabilities). -->
 
Julia programs can reuse libraries from other languages (or itself be reused from other); Julia has a special no-boilerplate keyword allowing calling e.g. [[C (programming language)|C]], [[Fortran]] or [[Rust (programming language)|Rust]] libraries, and e.g. PythonCall.jl uses it indirectly for you, and Julia (libraries) can also be called from other languages, e.g. [[Python (programming language)|Python]] and [[R (programming language)|R]], and several Julia packages have been made easily available from those languages, in the form of Python and R [[library (computing)|libraries]] for corresponding Julia packages. Calling in either direction has been implemented for many languages, not just those and [[C++]].
 
Julia is supported by programmer tools like IDEs (see below) and by notebooks like Pluto.jl, [[Project Jupyter|Jupyter]], and since 2025 [[Google Colab]] officially supports Julia natively.
<!--
For now also commented out (see Talk, and above shorter text):
Julia's [[Visual Studio Code]] extension provides a fully-featured [[integrated development environment]] with "built-in dynamic autocompletion, inline results, plot pane, integrated REPL, variable view, code navigation, and many other advanced language features"<ref>{{Cite news |title=Julia in Visual Studio Code |url=https://code.visualstudio.com/docs/languages/julia}}</ref> e.g. debugging is possible, [[lint (software)|linting]], and [[profiling (computer programming)|profiling]].<ref>{{Cite web|last=Holy|first=Tim|title=GitHub - timholy/ProfileView.jl: Visualization of Julia profiling data.|website=[[GitHub]]|date=2019-09-13|url=https://github.com/timholy/ProfileView.jl|access-date=2019-09-22|archive-date=31 January 2020|archive-url=https://web.archive.org/web/20200131231452/https://github.com/timholy/ProfileView.jl|url-status=live}}</ref><ref>{{Cite web|last=Gregg|first=Brendan|title=GitHub - brendangregg/FlameGraph: Stack trace visualizer.|website=[[GitHub]]|date=2019-09-20|url=https://github.com/brendangregg/FlameGraph|access-date=2019-09-22|archive-date=26 September 2019|archive-url=https://web.archive.org/web/20190926230048/https://github.com/brendangregg/FlameGraph|url-status=live}}</ref><ref>{{Cite web|url=https://julialang.org/blog/2019/03/debuggers|title=A Julia interpreter and debugger|website=julialang.org|access-date=2019-04-10}}</ref><ref>{{Cite web|url=https://timholy.github.io/Rebugger.jl/dev/|title=Home · Rebugger.jl|website=timholy.github.io|access-date=2019-04-10|archive-date=31 March 2019|archive-url=https://web.archive.org/web/20190331171846/https://timholy.github.io/Rebugger.jl/dev/|url-status=live}}</ref>
 
Some state-of-the-art software has already been written in Julia, because it's considered easier to do then in the other popular languages. Some of it can also be used from other languages like Python or R. Julia was designed to be unusually easy to work with other languages, i.e. to benefit from code already written in other languages, to "reuse" their code.
-->
 
Julia is sometimes used in [[embedded system]]s (e.g. has been used in a satellite in space on a [[Raspberry Pi]] Compute Module 4; 64-bit Pis work best with Julia, and Julia is supported in [[Raspbian]]).<ref>{{cite web |url=https://julialang.org/blog/2017/05/raspberry-pi-julia |title=Julia available in Raspbian on the Raspberry Pi |quote=Julia works on all the Pi variants, we recommend using the Pi 3.}}</ref>
 
==History==
Work on Julia began in 2009, when [[Jeff Bezanson (programmer)|Jeff Bezanson]], [[Stefan Karpinski]], [[Viral B. Shah]], and [[Alan Edelman]] set out to create a free language that was both high-level and fast. On 14 February 2012, the team launched a website with a blog post explaining the language's mission.<ref name="announcement" /> In an interview with ''[[InfoWorld]]'' in April 2012, Karpinski said of the name "Julia": "There's no good reason, really. It just seemed like a pretty name."<ref name="infoworld">{{Cite magazine
| last = Krill
| first = Paul
| title = New Julia language seeks to be the C for scientists
| url = https://www.infoworld.com/article/2616709/new-julia-language-seeks-to-be-the-c-for-scientists.html
| magazine = InfoWorld
| date = 18 April 2012
| access-date = 4 July 2021
| archive-date= 13 September 2014
| archive-url = https://web.archive.org/web/20140913234252/http://www.infoworld.com/d/application-development/new-julia-language-seeks-be-the-c-scientists-190818
| url-status = live
}}</ref> Bezanson said he chose the name on the recommendation of a friend,<ref>{{Cite web |last1=Torre |first1=Charles |title=Stefan Karpinski and Jeff Bezanson on Julia |url=https://channel9.msdn.com/Blogs/Charles/Stefan-Karpinski-and-Jeff-Bezanson-Julia-Programming-Language |website=Channel 9 |publisher=MSDN |access-date=4 December 2018 |archive-date=4 December 2018 |archive-url=https://web.archive.org/web/20181204102053/https://channel9.msdn.com/Blogs/Charles/Stefan-Karpinski-and-Jeff-Bezanson-Julia-Programming-Language |url-status=live }}</ref> then years later wrote:
 
{{blockquote|Maybe julia stands for "[[Jeff Bezanson (programmer)|Jeff]]'s [[MLisp|uncommon lisp]] is automated"?<ref>{{Cite web |last1=Bezanson |first1=Jeff |title=CAS Benchmarks |url=https://discourse.julialang.org/t/cas-benchmarks-symbolics-jl-and-maxima/58359/17 |website=discourse.julialang.org |date=2 April 2021 |access-date=2 April 2021 |archive-date=2 April 2021 |archive-url=https://web.archive.org/web/20210402224346/https://discourse.julialang.org/t/cas-benchmarks-symbolics-jl-and-maxima/58359/17 |url-status=live }}</ref>}}
 
Julia's [[syntax (programming languages)|syntax]] is now considered stable, since version 1.0 in 2018, and Julia has a [[backward compatibility]] guarantee for 1.x and also a stability promise for the documented (stable) [[application programming interface|API]], while in the years before in the early development prior to 0.7 the syntax (and semantics) was changed in new versions. All of the (registered package) [[ecosystem]] uses the new and improved syntax, and in most cases relies on new APIs that have been added regularly, and in some cases minor additional syntax added in a forward compatible way e.g. in Julia&nbsp;1.7.
 
In the 10 years since the 2012 launch of pre-1.0 Julia, the community has grown. The Julia package ecosystem has over 11.8 million lines of code (including docs and tests).<ref>{{Cite web |title=Newsletter August 2021 - Julia Computing Completes $24 Million Series A Fundraise and Former Snowflake CEO Bob Muglia Joins Julia Computing Board of Directors - JuliaHub |url=https://juliahub.com/blog/2021/08/newsletter-august/ |access-date=2022-11-16 |website=juliahub.com |archive-date=16 November 2022 |archive-url=https://web.archive.org/web/20221116115927/https://juliahub.com/blog/2021/08/newsletter-august/ |url-status=live }}</ref> The JuliaCon [[academic conference]] for Julia users and developers has been held annually since 2014 with JuliaCon2020<ref>{{Cite web |title=JuliaCon 2020 |url=https://juliacon.org/2020/ |access-date=2023-10-06 |website=JuliaCon 2020 |language=en |archive-date=12 October 2023 |archive-url=https://web.archive.org/web/20231012155924/https://juliacon.org/2020/ |url-status=live }}</ref> welcoming over 28,900 unique viewers,<ref>{{Cite web|date=2020-08-11|title=JuliaCon 2020 Wrap-up|url=https://julialang.org/blog/2020/08/juliacon-2020-wrapup/#outcomes|access-date=2020-12-20|website=julialang.org|archive-date=30 November 2020|archive-url=https://web.archive.org/web/20201130113640/https://julialang.org/blog/2020/08/juliacon-2020-wrapup/#outcomes|url-status=live}}</ref> and then JuliaCon2021 breaking all previous records (with more than 300 JuliaCon2021 presentations available for free on YouTube, up from 162 the year before), and 43,000 unique viewers during the conference.<ref>{{Cite web|title=JuliaCon 2021 Highlights|url=https://julialang.org/blog/2021/08/juliacon-highlights/|access-date=2021-09-06|website=julialang.org|language=en|archive-date=6 September 2021|archive-url=https://web.archive.org/web/20210906222719/https://julialang.org/blog/2021/08/juliacon-highlights/|url-status=live}}</ref>
 
Three of the Julia co-creators are the recipients of the 2019 [[J. H. Wilkinson Prize for Numerical Software|James H. Wilkinson Prize for Numerical Software]] (awarded every four years) "for the creation of Julia, an innovative environment for the creation of high-performance tools that enable the analysis and solution of computational science problems."<ref>{{Cite web |title=Julia language co-creators win James H. Wilkinson Prize for Numerical Software |url=https://news.mit.edu/2018/julia-language-co-creators-win-james-wilkinson-prize-numerical-software-1226 |access-date=2019-01-22 |website=MIT News |date=26 December 2018 |archive-date=28 January 2019 |archive-url=https://web.archive.org/web/20190128230208/http://news.mit.edu/2018/julia-language-co-creators-win-james-wilkinson-prize-numerical-software-1226 |url-status=live }}</ref> Also, Alan Edelman, professor of [[applied mathematics]] at [[Massachusetts Institute of Technology|MIT]], has been selected to receive the 2019 [[Institute of Electrical and Electronics Engineers|IEEE Computer Society]] [[Sidney Fernbach Award]] "for outstanding breakthroughs in high-performance computing, linear algebra, and computational science and for contributions to the Julia programming language."<ref>{{Cite press release |url=https://www.computer.org/press-room/2019-news/2019-ieee-fernbach-award-edelman |title=Alan Edelman of MIT Recognized with Prestigious 2019 IEEE Computer Society Sidney Fernbach Award {{!}} IEEE Computer Society |language=en-US |date=1 October 2019 |access-date=2019-10-09 |archive-date=9 October 2019 |archive-url=https://web.archive.org/web/20191009130947/https://www.computer.org/press-room/2019-news/2019-ieee-fernbach-award-edelman |url-status=live }}</ref>
 
<!-- Version 0.3 was released in August 2014, version 0.6 in June 2017.<ref>{{Cite web|url=https://julialang.org/blog/2017/06/julia-0.6-release|title=Julia 0.6 Release Announcement}}</ref> -->
Both Julia 0.7<ref>{{Cite web|url=https://discourse.julialang.org/t/what-is-julia-0-7-how-does-it-relate-to-1-0/9994|title=What is Julia 0.7? How does it relate to 1.0?|website=JuliaLang|date=26 March 2018|language=en|access-date=2018-10-17|archive-date=27 July 2018|archive-url=https://web.archive.org/web/20180727054635/https://discourse.julialang.org/t/what-is-julia-0-7-how-does-it-relate-to-1-0/9994|url-status=live}}</ref> and version 1.0 were released on 8 August 2018. Work on Julia 0.7 was a "huge undertaking" (e.g., because of an "entirely new optimizer"), and some changes were made to semantics, e.g. the [[iteration]] interface was simplified.<ref>{{Cite web |url=https://julialang.org/blog/2018/07/iterators-in-julia-0.7 |title=Writing Iterators in Julia 0.7 |first=Eric |last=Davies |website=julialang.org |access-date=2018-08-05 |archive-date=6 August 2018 |archive-url=https://web.archive.org/web/20180806024646/https://julialang.org/blog/2018/07/iterators-in-julia-0.7 |url-status=live }}</ref>
<!--
Julia&nbsp;1.1 was released in January 2019 with a new "exception stack" feature. Julia&nbsp;1.2 was released in August 2019 with some built-in support for web browsers.<ref>{{Cite web|title=Sys.isjsvm([os])|date=2019-08-20|url=https://github.com/JuliaLang/julia/blob/75c10e435b2b9c947422ad38fa0b020595d3f747/base/sysinfo.jl#L401|quote=Predicate for testing if Julia is running in a JavaScript VM (JSVM), including e.g. a WebAssembly JavaScript embedding in a web browser.|publisher=The Julia Language|access-date=2019-08-20}}</ref> Julia&nbsp;1.3 added composable multi-threaded parallelism and a binary artifacts system for Julia packages.<ref>{{Cite web|url=https://julialang.org/blog/2019/11/artifacts|title=The Julia Language|first1=Jeff|last1=Bezanson|first2=Stefan|last2=Karpinski|first3=Viral|last3=Shah|first4=Alan|last4=Edelman|website=julialang.org|access-date=2019-12-13}}</ref> Julia&nbsp;1.4 added syntax for generic array indexing to handle e.g. [[zero-based numbering#Usage in programming languages|0-based]] arrays.<ref>{{Cite web|url=https://github.com/JuliaLang/julia/pull/33946|title=support a[begin] for a[firstindex(a)] by stevengj · Pull Request #33946 · JuliaLang/julia|website=GitHub|language=en|access-date=2020-04-07}}</ref> The memory model was also changed.<ref>{{Cite web|url=https://github.com/JuliaLang/julia/pull/32448|title=For structs with all isbits or isbitsunion fields, allow them to be s<!-…->tored inline in arrays <!-by quinnj-> · Pull Request #32448 · JuliaLang/julia|author=quinnj|quote=I still keep running into problems that this causes internally because it was a breaking change that changes assumptions made by some users and inference/codegen.|website=GitHub|language=en|access-date=2020-04-07}}</ref> Julia&nbsp;1.5 released in August 2020 added [[record and replay debugging]] support,<ref>{{Cite web|title=Coming in Julia 1.5: Time Traveling (Linux) Bug Reporting|url=https://julialang.org/blog/2020/05/rr/|date=2 May 2020 |first=Keno |last=Fischer|website=julialang.org|language=en|quote=Overhead for recording of single threaded processes is generally below 2x, most often between 2% and 50% (lower for purely numerical calculations, higher for workloads that interact with the OS). Recording multiple threads or processes that share memory (as opposed to using kernel-based message passing) is harder. [..] As expected, the threads test is the worst offender with about 600% overhead. |access-date=2020-05-05}}</ref> for Mozilla's [[rr (debugging)|rr]] tool. <!- It can be used manually in earlier versions, without Julia's help. ->
 
The release changed the behavior in the [[read–eval–print loop|REPL]] (soft scope) to the one used in [[Project Jupyter|Jupyter]], but fully compatible with non-REPL code. Most of the [[thread (computing)|thread API]] was marked as stable, and with this release "arbitrary immutable objects—regardless of whether they have fields that reference mutable objects or not—can now be stack allocated",<ref>{{Cite web|author1=Jeff Bezanson |author2=Stefan Karpinski |author3=Viral Shah |author4=Alan Edelman |display-authors=etal |title=The Julia Language|url=https://julialang.org/blog/2020/08/julia-1.5-highlights/|access-date=2020-08-14|quote=There are some size-based limits to which structs can be stack allocated, but they are unlikely to be exceeded in practice.|website=julialang.org|language=en}}</ref> reducing heap allocations, e.g. <code>views</code> are no longer allocating. <!- "± and ∓ are now unary operators as well, like + or -" -> Julia&nbsp;1.5 targeted so-called "time-to-first-plot" (TTFP, also called TTFX, for first X, the more general problem) performance, in general, the speed of compilation itself (as opposed to performance of the generated code), and added tools for developers to improve package loading.<ref>{{Cite web|author1=Jeff Bezanson |author2=Stefan Karpinski |author3=Viral Shah |author4=Alan Edelman |display-authors=etal |title=The Julia Language|url=https://julialang.org/blog/2020/08/invalidations/|access-date=2020-09-16|website=julialang.org|language=en}}</ref>
-->Julia 1.6 was the largest release since 1.0, and it was the [[long-term support]] (LTS) version for the longest time, faster on many fronts, e.g. introduced parallel precompilation and faster loading of packages, in some cases "50x speedup in load times for large trees of binary artifacts".<ref>{{Cite web|author1=Jeff Bezanson|author2=Stefan Karpinski|author3=Viral Shah|author4=Alan Edelman|display-authors=etal|title=Julia 1.6 Highlights|url=https://julialang.org/blog/2021/03/julia-1.6-highlights/|access-date=2021-03-26|website=julialang.org|language=en|archive-date=26 March 2021|archive-url=https://web.archive.org/web/20210326155220/https://julialang.org/blog/2021/03/julia-1.6-highlights/|url-status=live}}</ref> Since 1.7 Julia development is back to [[release early, release often|time-based releases]].<ref>{{Cite web|title=Upgrade to OpenBLAS 0.3.13 · Pull Request #39216 · JuliaLang/julia|url=https://github.com/JuliaLang/julia/pull/39216#issuecomment-816285199|access-date=2021-04-26|website=GitHub|language=en|quote=Given that 1.7 is not too far away (timed releases going forward)|archive-date=23 March 2022|archive-url=https://web.archive.org/web/20220323054712/https://github.com/JuliaLang/julia/pull/39216#issuecomment-816285199|url-status=live}}</ref> Julia&nbsp;1.7 was released in November 2021 with many changes, e.g. a new faster [[random number generation|random-number generator]] and Julia&nbsp;1.7.3 fixed e.g. at least one security issue.<ref>{{Cite web |title=[Zlib_jll] Update to v1.2.12+3 by giordano · Pull Request #44810 · JuliaLang/julia |url=https://github.com/JuliaLang/julia/pull/44810 |access-date=2022-05-25 |website=GitHub |language=en |archive-date=25 May 2022 |archive-url=https://web.archive.org/web/20220525225959/https://github.com/JuliaLang/julia/pull/44810 |url-status=live }}</ref> Julia&nbsp;1.8 was released in 2022 and 1.8.5 in January 2023,<ref>{{Cite web |title=Backports for Julia 1.8.5 by KristofferC · Pull Request #48011 · JuliaLang/julia |url=https://github.com/JuliaLang/julia/pull/48011 |access-date=2023-01-08 |website=GitHub |language=en |archive-date=4 January 2023 |archive-url=https://web.archive.org/web/20230104192611/https://github.com/JuliaLang/julia/pull/48011 |url-status=live }}</ref> <!-- both fixing bugs ([[backporting]]) and "invalidations", thus compiling faster),--> with 1.8.x improvements for distributing Julia programs without source code, <!-- --strip-metadata and --strip-ir --> and compiler speedup, in some cases by 25%,<ref>{{Cite web |title=compiler: speed up bootstrapping time by 25% by aviatesk · Pull Request #41794 · JuliaLang/julia |url=https://github.com/JuliaLang/julia/pull/41794 |access-date=2022-03-03 |website=GitHub |language=en |quote=the bootstrapping took about 80 seconds previously, but on this PR the time is reduced to about 60 seconds. |archive-date=3 March 2022 |archive-url=https://web.archive.org/web/20220303155817/https://github.com/JuliaLang/julia/pull/41794 |url-status=live }}</ref> <!-- "Bootstrapping time has been improved by about 25%" --> and more controllable [[inline expansion|inlining]] (i.e. now also allowing applying <code>@inline</code> at the call site, not just on the function itself). Julia 1.9 was released on 7 May 2023. It has many improvements, <!-- such as solving the TTFX/TTFP problem; --> such as the ability to precompile packages to native machine code (older Julia versions also have precompilation for packages, but only partial, never fully to native code, so those earlier versions had a "first use" penalty, slowing down while waiting to fully compile). Precompiled packages, since version 1.9, can be up to hundreds of times faster on first use (e.g. for ''CSV.jl'' and ''DataFrames.jl''), and to improve precompilation of packages a new package ''PrecompileTools.jl'' has been introduced. Julia 1.10 was released on 25 December 2023 with many new features, e.g. parallel garbage collection, and improved package load times and a new parser, i.e. it rewritten in Julia, with better error messages and improved stacktrace rendering.<ref>{{Cite web |title=julia/HISTORY.md at master · JuliaLang/julia |url=https://github.com/JuliaLang/julia/blob/master/HISTORY.md#julia-v110-release-notes |access-date=2024-12-01 |website=GitHub |language=en}}</ref><!--
Package load time improvements
Improvements in stacktrace rendering
Parallel garbage collection
Tracy and Intel VTune ITTAPI profiling integration
Upgrade to LLVM 15
Linux AArch64 stability improvements
Parallel native code generation for system images and package images
Avoiding races during parallel precompilation
Parallel precompile on using
-->
 
Julia 1.11 was released on 7 October 2024 (and 1.11.6 on 9 July 2025), and with it 1.10.5 became the next [[long-term support]] (LTS) version (i.e. those are the only two supported versions), since replaced by 1.10.10 released on 27 June, and 1.6 is no longer an LTS version. Julia 1.11 adds e.g. parallel garbage collection and the new <code>public</code> keyword to signal safe public API (Julia users are advised to use such API, not internals, of Julia or packages, and package authors advised to use the keyword, generally indirectly, e.g. prefixed with the <code>@compat</code> macro, from ''Compat.jl'', to also support older Julia versions, at least the LTS version). Julia 1.11.1 has much improved startup (over 1.11.0 that had a regression), and over 1.10, and this can be important for some benchmarks.
 
<!-- I think this is now outdated: Some users may want to postpone upgrading to 1.11 (e.g. those calling Julia from R), because of known temporary package incompatibility.
-->
It's possible to compile very small binary executables using <code>juliac</code> which is available in the upcoming Julia 1.12 (now in beta3), and other compilers exist usable for older Julia versions, that also allows compiling though not to small binaries with the main one.
 
===JuliaCon===
Since 2014,<ref>{{Cite web|url=https://juliacon.org/2014/|title=JuliaCon 2014|website=juliacon.org|access-date=2021-06-20}}</ref> the Julia Community has hosted an annual Julia Conference focused on developers and users. The first JuliaCon took place in Chicago and kickstarted the annual occurrence of the conference. Since 2014, the conference has taken place across a number of locations including MIT<ref>{{Cite web|url=https://news.mit.edu/2016/juliacon-draws-global-users-of-dynamic-programming-language-0718|title=JuliaCon 2016 at MIT|website=mit.edu|date=18 July 2016|access-date=2021-06-20|archive-date=24 June 2021|archive-url=https://web.archive.org/web/20210624201658/https://news.mit.edu/2016/juliacon-draws-global-users-of-dynamic-programming-language-0718|url-status=live}}</ref> and the University of Maryland, Baltimore.<ref>{{Cite web|url=https://technical.ly/baltimore/2019/07/23/juliacon-provides-the-stage-for-a-week-of-programming-talks-and-a-new-baltimore-company/|title=JuliaCon 2019 at UMB|website=technical.ly|date=23 July 2019|access-date=2021-06-20|archive-date=24 June 2021|archive-url=https://web.archive.org/web/20210624201651/https://technical.ly/baltimore/2019/07/23/juliacon-provides-the-stage-for-a-week-of-programming-talks-and-a-new-baltimore-company/|url-status=live}}</ref> The event audience has grown from a few dozen people to over 28,900 unique attendees<ref>{{Cite web|url=https://julialang.org/blog/2020/08/juliacon-2020-wrapup/#outcomes|title=JuliaCon 2020 wrap up|website=julialang.org|access-date=2021-06-20|archive-date=30 November 2020|archive-url=https://web.archive.org/web/20201130113640/https://julialang.org/blog/2020/08/juliacon-2020-wrapup/#outcomes|url-status=live}}</ref> during JuliaCon 2020, which took place virtually. JuliaCon 2021 also took place virtually<ref>{{Cite web|url=https://juliacon.org/2021/|title=JuliaCon 2021|website=Juliacon.org|access-date=2021-06-20|archive-date=20 June 2021|archive-url=https://web.archive.org/web/20210620034020/https://juliacon.org/2021/|url-status=live}}</ref> with keynote addresses from professors [[William Kahan]], the primary architect of the [[IEEE 754-1985|IEEE 754]] floating-point standard (which virtually all CPUs and languages, including Julia, use),<ref>{{Cite web |title=JuliaCon 2021 Highlights |url=https://julialang.org/blog/2021/08/juliacon-highlights/ |access-date=2022-03-03 |website=julialang.org |language=en |quote=This year's JuliaCon was the biggest and best ever, with more than 300 presentations available for free on YouTube, more than 20,000 registrations, and more than 43,000 unique YouTube viewers during the conference, up from 162 presentations, 10,000 registrations, and 28,900 unique YouTube viewers during last year's conference. |archive-date=6 September 2021 |archive-url=https://web.archive.org/web/20210906222719/https://julialang.org/blog/2021/08/juliacon-highlights/ |url-status=live }}</ref> Jan Vitek,<ref>{{Cite web|url=https://janvitek.org/|title=Jan Vitek Homepage|website=janvitek.org|access-date=2021-06-20|archive-date=22 January 2024|archive-url=https://web.archive.org/web/20240122214511/https://janvitek.org/|url-status=live}}</ref> Xiaoye [[Sherry Li]], and Soumith Chintala, a co-creator of [[PyTorch]].<ref>{{Cite web|url=https://soumith.ch/|title=Soumith Chintala Homepage|website=soumith.ch|access-date=2021-06-20|archive-date=24 June 2021|archive-url=https://web.archive.org/web/20210624202250/https://soumith.ch/|url-status=live}}</ref> JuliaCon grew to 43,000 unique attendees and more than 300 presentations (still freely accessible, plus for older years). JuliaCon 2022 will also be virtual held between July 27 and July 29, 2022, for the first time in several languages, not just in English.
 
===Sponsors===
The Julia language became a NumFOCUS fiscally sponsored project in 2014 in an effort to ensure the project's long-term sustainability.<ref>{{Cite web|url=https://numfocus.org/project/julia|title=Julia: NumFOCUS Sponsored Project since 2014|website=numfocus.org|access-date=2020-09-29|archive-date=28 September 2020|archive-url=https://web.archive.org/web/20200928023230/https://numfocus.org/project/julia|url-status=live}}</ref> Jeremy Kepner at [[MIT Lincoln Laboratory]] was the founding sponsor of the Julia project in its early days. In addition, funds from the [[Gordon and Betty Moore Foundation]], the [[Alfred P. Sloan Foundation]], [[Intel]], and agencies such as [[National Science Foundation|NSF]], [[DARPA]], [[National Institutes of Health|NIH]], [[NASA]], and [[Federal Aviation Administration|FAA]] have been essential to the development of Julia.<ref>{{Cite web|url=https://julialang.org/research/|title=The Julia Language|website=julialang.org|access-date=2019-09-22|archive-date=26 July 2019|archive-url=https://web.archive.org/web/20190726215130/https://julialang.org/research/|url-status=live}}</ref> [[Mozilla]], the maker of Firefox web browser, with its research grants for H1 2019, sponsored "a member of the official Julia team" for the project "Bringing Julia to the Browser",<ref>{{Cite web|url=https://www.zdnet.com/article/mozilla-is-funding-a-way-to-support-julia-in-firefox/|title=Mozilla is funding a way to support Julia in Firefox|last=Cimpanu|first=Catalin|website=ZDNet|language=en|access-date=2019-09-22|archive-date=10 July 2019|archive-url=https://web.archive.org/web/20190710012226/https://www.zdnet.com/article/mozilla-is-funding-a-way-to-support-julia-in-firefox/|url-status=live}}</ref> meaning to Firefox <!-- "and the general browser environment--> and other web browsers.<ref>{{Cite web|url=https://alpha.iodide.io/notebooks/225/|archive-url=https://web.archive.org/web/20190922161033/https://alpha.iodide.io/notebooks/225/|url-status=dead|archive-date=22 September 2019|title=Julia in Iodide|website=alpha.iodide.io|access-date=2019-09-22}}</ref><ref>{{Cite web|url=https://iodide-project.github.io/docs/language_plugins/|title=Language plugins - Iodide Documentation|website=iodide-project.github.io|access-date=2019-09-22|archive-date=22 September 2019|archive-url=https://web.archive.org/web/20190922161121/https://iodide-project.github.io/docs/language_plugins/|url-status=live}}</ref><ref>{{Cite web|url=https://mozilla-research.forms.fm/mozilla-research-grants-2019h1/forms/6510|title=Mozilla Research Grants 2019H1|website=Mozilla|language=en|quote=running language interpreters in WebAssembly. To further increase access to leading data science tools, we're looking for someone to port R or Julia to WebAssembly and to attempt to provide a level 3 language plugin for Iodide: automatic conversion of data basic types between R/Julia and Javascript, and the ability to share class instances between R/Julia and Javascript.|access-date=2019-09-22|archive-date=9 October 2019|archive-url=https://web.archive.org/web/20191009130024/https://mozilla-research.forms.fm/mozilla-research-grants-2019h1/forms/6510}}</ref><ref>{{Cite web|title=Literate scientific computing and communication for the web: iodide-project/iodide|date=2019-09-20|url=https://github.com/iodide-project/iodide|publisher=iodide|quote=We envision a future workflow that allows you to do your data munging in Python, fit a quick model in R or JAGS, solve some differential equations in Julia, and then display your results with a live interactive d3+JavaScript visualization&nbsp;... and all that within a single, portable, sharable, and hackable file.|access-date=2019-09-22|archive-date=24 August 2018|archive-url=https://web.archive.org/web/20180824140212/https://github.com/iodide-project/iodide|url-status=live}}</ref> The Julia language is also supported by individual donors on GitHub.<ref>{{Cite web|url=https://github.com/sponsors/JuliaLang|title=Sponsor the Julia Language|website=github.com|access-date=2021-06-05|archive-date=5 July 2021|archive-url=https://web.archive.org/web/20210705013745/https://github.com/sponsors/JuliaLang|url-status=live}}</ref>
 
===The Julia company===
JuliaHub, Inc. was founded in 2015 as Julia Computing, Inc. by [[Viral B. Shah]], Deepak Vinchhi, [[Alan Edelman]], [[Jeff Bezanson]], [[Stefan Karpinski]] and [[Keno Fischer]].<ref>{{Cite web|url=https://juliacomputing.com/about-us|title=About Us – Julia Computing|website=juliacomputing.com|access-date=2017-09-12|archive-date=1 September 2019|archive-url=https://web.archive.org/web/20190901171449/https://juliacomputing.com/about-us|url-status=live}}</ref><ref>{{Cite web |title=About Us - JuliaHub |url=https://juliahub.com/company/about-us/ |access-date=2022-11-16 |website=juliahub.com |archive-date=16 November 2022 |archive-url=https://web.archive.org/web/20221116112437/https://juliahub.com/company/about-us/ |url-status=live }}</ref>
 
In June 2017, Julia Computing raised US$4.6{{nbsp}}million in seed funding from [[General Catalyst]] and Founder Collective,<ref>{{Cite press release|url=https://juliacomputing.com/communication/2017/06/19/seed-funding.html|title=Julia Computing Raises $4.6M in Seed Funding|archive-url=https://web.archive.org/web/20190510040656/https://juliacomputing.com/communication/2017/06/19/seed-funding.html|archive-date=2019-05-10}}</ref> the same month was "granted $910,000 by the [[Alfred P. Sloan Foundation]] to support [[open-source software|open-source]] Julia development, including $160,000 to promote diversity in the Julia community",<ref>{{Cite news|date=2017-06-26|title=Julia Computing Awarded $910,000 Grant by Alfred P. Sloan Foundation, Including $160,000 for STEM Diversity|url=https://juliacomputing.com/media/2017/06/26/sloan-grant.html|access-date=2020-07-28|website=juliacomputing.com|archive-date=3 August 2020|archive-url=https://web.archive.org/web/20200803093745/https://juliacomputing.com/media/2017/06/26/sloan-grant.html}}</ref> and in December 2019 the company got $1.1{{nbsp}}million funding from the US government to "develop a neural component [[machine learning]] tool to reduce the total energy consumption of heating, ventilation, and air conditioning (HVAC) systems in buildings".<ref>{{Cite web|title=DIFFERENTIATE—Design Intelligence Fostering Formidable Energy Reduction (and) Enabling Novel Totally Impactful Advanced Technology Enhancements|url=https://arpa-e.energy.gov/sites/default/files/documents/files/DIFFERENTIATE_Project_Descriptions_FINAL.pdf}}</ref> In July 2021, Julia Computing announced they raised a $24 million [[Series A round]] led by Dorilton Ventures,<ref>{{Cite news|title=Julia Computing raises $24 mln in funding round led by Dorilton Ventures|newspaper=Reuters|date=19 July 2021|url=https://www.reuters.com/technology/julia-computing-raises-24-mln-funding-round-led-by-dorilton-ventures-2021-07-19/|access-date=18 August 2021|archive-date=18 August 2021|archive-url=https://web.archive.org/web/20210818161926/https://www.reuters.com/technology/julia-computing-raises-24-mln-funding-round-led-by-dorilton-ventures-2021-07-19/|url-status=live}}</ref> which also owns {{nowrap|[[Formula 1]]}} team [[Williams Grand Prix Engineering|Williams Racing]], that partnered with Julia Computing. Williams' Commercial Director said: "Investing in companies building best-in-class cloud technology is a strategic focus for Dorilton and Julia's versatile platform, with revolutionary capabilities in simulation and modelling, is hugely relevant to our business. We look forward to embedding Julia Computing in the world's most technologically advanced sport".<ref>{{Cite press release|title=Williams welcomes Julia Computing as Dorilton Ventures partner|url=https://www.williamsf1.com/news/2021/partners/williams-welcomes-julia-computing|access-date=2021-09-02|website=www.williamsf1.com|language=en|archive-date=2 September 2021|archive-url=https://web.archive.org/web/20210902092335/https://www.williamsf1.com/news/2021/partners/williams-welcomes-julia-computing|url-status=live}}</ref> In June 2023, JuliaHub received (again, now under its new name) a $13 million strategic new investment led by AE Industrial Partners HorizonX ("AEI HorizonX"). AEI HorizonX is a venture capital investment platform formed in partnership with [[Boeing|The Boeing Company]], which uses Julia.<ref>{{Cite press release |title=JuliaHub Receives $13 Million Strategic Investment from AE Industrial Partners HorizonX |url=https://info.juliahub.com/juliahub-receives-13-million-strategic-investment-from-ae-industrial-partners-horizonx |date=June 27, 2023 |access-date=2023-06-30 |website=info.juliahub.com |language=en}}</ref> Tim Holy's work (at [[Washington University in St. Louis]]'s Holy Lab) on Julia&nbsp;1.9 (improving responsiveness) was funded by the [[Chan Zuckerberg Initiative]].<!-- Acknowledgments: The work by Tim Holy was funded by the Chan Zuckerberg Initiative. JuliaHub thanks NASA for their support through NASA ROSES 20-OSTFL20-0018. Valentin Churavy gratefully acknowledges funding from NSF (grants OAC-1835443, OAC-2103804, AGS-1835860, and AGS-1835881). This research was made possible by the generosity of Eric and Wendy Schmidt by recommendation of the Schmidt Futures program, by the Paul G. Allen Family Foundation, Charles Trimble, Audi Environmental Foundation. This material is based upon work supported by the Department of Energy, National Nuclear Security Administration under Award Number DE-NA0003965. The views and opinions of authors expressed herein do not necessarily state or reflect those of the United States government or any agency thereof. -->
 
==Language features==
{{Wikibooks|Introducing Julia}}
 
Julia is a [[general-purpose programming language]],<ref>{{Cite web
| title = The Julia Language
| type = official website
| url = https://julialang.org/
| quote = General Purpose [..] Julia lets you write UIs, statically compile your code, or even deploy it on a webserver.
| access-date = 9 December 2016
| archive-date = 21 February 2017
| archive-url = https://web.archive.org/web/20170221073014/http://julialang.org/
| url-status = live
}}</ref> while also originally designed for numerical/technical computing. It is also useful for low-level [[system programming|systems programming]],<ref name="LowLevelSystemsProgrammingInJulia">{{Cite web |url=https://juliacon.org/2018/talks_workshops/42/
|archive-url=https://web.archive.org/web/20181105083419/http://juliacon.org/2018/talks_workshops/42/
|archive-date=5 November 2018
|first=Todd |last=Green
|title=Low-Level Systems Programming in High-Level Julia
|date=10 August 2018
|access-date=5 November 2018
}}</ref> as a [[specification language]],<ref name="spec">{{Cite web|last=Moss|first=Robert|date=26 June 2015|title=Using Julia as a Specification Language for the Next-Generation Airborne Collision Avoidance System|url=https://juliacon.org/2015/images/juliacon2015_moss_v3.pdf|url-status=live|archive-url=https://web.archive.org/web/20150701182804/http://juliacon.org/talks.html|archive-date=1 July 2015|access-date=29 June 2015|quote=[[Airborne collision avoidance system]]}}</ref> high-level synthesis (HLS) tool (for hardware, e.g. [[field-programmable gate array|FPGA]]s),<ref name = "HLS/FPGA">{{Cite arXiv|title=High-level Synthesis using the Julia Language |eprint=2201.11522 |quote=We present a prototype Julia HLS tool, written in Julia, that transforms Julia code to VHDL.|last1=Biggs |first1=Benjamin |last2=McInerney |first2=Ian |last3=Kerrigan |first3=Eric C. |last4=Constantinides |first4=George A. |year=2022 |class=cs.SE }}</ref> and for web programming<ref>{{Cite press release|work=plotly|date=2020-10-26|title=Announcing Dash for Julia|url=https://medium.com/plotly/announcing-dash-for-julia-f017c90c6ef1|access-date=2021-09-02|language=en|archive-date=2 September 2021|archive-url=https://web.archive.org/web/20210902094440/https://medium.com/plotly/announcing-dash-for-julia-f017c90c6ef1|url-status=live}}</ref> at both server<ref>{{Cite web|url=https://medium.com/@richardanaya/how-to-create-a-multi-threaded-http-server-in-julia-ca12dca09c35|title=How to create a multi-threaded HTTP server in Julia|last=Anaya|first=Richard|date=2019-04-28|website=Medium|language=en|access-date=2019-07-25|quote=In summary, even though Julia lacks a multi-threaded server solution currently out of box, we can easily take advantage of its process distribution features and a highly popular load balancing tech to get full CPU utilization for HTTP handling.|archive-date=25 July 2019|archive-url=https://web.archive.org/web/20190725161314/https://medium.com/@richardanaya/how-to-create-a-multi-threaded-http-server-in-julia-ca12dca09c35|url-status=live}}</ref><ref>{{Cite web|last=Anthoff|first=David|title=Node.js installation for julia|website=[[GitHub]]|date=2019-06-01|url=https://github.com/davidanthoff/NodeJS.jl|access-date=2019-07-25|archive-date=4 September 2024|archive-url=https://web.archive.org/web/20240904035046/https://github.com/davidanthoff/NodeJS.jl|url-status=live}}</ref> and client<ref name="JSExpr">{{Cite web |date=2019-07-07 |title=Translate Julia to JavaScript |url=https://github.com/JuliaGizmos/JSExpr.jl |access-date=2019-07-25 |publisher=JuliaGizmos |archive-date=28 March 2019 |archive-url=https://web.archive.org/web/20190328210322/https://github.com/JuliaGizmos/JSExpr.jl |url-status=live }}</ref><ref name="WebAssembly">{{Cite web |last=Fischer |first=Keno |date=2019-07-22 |title=Running julia on wasm |url=https://github.com/Keno/julia-wasm |access-date=2019-07-25 |website=[[GitHub]] |archive-date=21 November 2020 |archive-url=https://web.archive.org/web/20201121081548/https://github.com/keno/julia-wasm |url-status=live }}</ref> side.
 
The main features of the language are:
* Multiple dispatch: providing ability to define function behavior across combinations of argument types
* [[Dynamic type]] system: types for documentation, optimization, and dispatch
* Performance approaching that of [[type system|statically-typed]] languages like C
* A built-in [[package manager]]
* [[Lisp (programming language)|Lisp]]-like macros and other [[metaprogramming]] facilities
* Designed for [[parallel computing|parallel]] and [[distributed computing]]
* [[Coroutine]]s: lightweight [[green thread|''green'' threading]]
* Automatic generation of code for different argument types
* Extensible conversions and promotions for numeric and other types
 
Multiple dispatch (also termed [[multimethod]]s in Lisp) is a [[generalization]] of [[single dispatch]]{{snd}} the [[polymorphism (computer science)|polymorphic mechanism]] used in common [[object-oriented programming]] (OOP) languages, such as [[Python (programming language)|Python]], [[C++]], [[Java (programming language)|Java]], [[JavaScript]], and [[Smalltalk]]{{snd}} that use [[inheritance (object-oriented programming)|inheritance]].
 
In Julia, all concrete types are [[subtyping|subtypes]] of abstract types, directly or indirectly subtypes of the <code>Any</code> type, which is the top of the type hierarchy. Concrete types cannot themselves be subtyped the way they can in other languages; composition is used instead (see also [[inheritance (object-oriented programming)#Inheritance vs subtyping|inheritance vs subtyping]]).
 
By default, the Julia runtime must be pre-installed as user-provided source code is run. Alternatively, Julia (GUI) apps can be quickly bundled up into a single file with ''AppBundler.jl''<ref name=AppBundler.jl>{{Cite web |title=AppBundler.jl |date=2023-12-13 |url=https://github.com/PeaceFounder/AppBundler.jl |access-date=2023-12-18 |publisher=PeaceFounder |archive-date=18 December 2023 |archive-url=https://web.archive.org/web/20231218172216/https://github.com/PeaceFounder/AppBundler.jl |url-status=live }}</ref> for "building Julia GUI applications in modern desktop application installer formats. It uses Snap for Linux, [[.msix|MSIX]] for Windows, and DMG for MacOS as targets. It bundles full Julia within the app".<ref>{{Cite web |date=2023-11-30 |title=[ANN] AppBundler.jl - Bundle Your Julia GUI Application |url=https://discourse.julialang.org/t/ann-appbundler-jl-bundle-your-julia-gui-application/106971 |access-date=2023-12-18 |website=Julia Programming Language |language=en |archive-date=4 September 2024 |archive-url=https://web.archive.org/web/20240904035046/https://discourse.julialang.org/t/ann-appbundler-jl-bundle-your-julia-gui-application/106971 |url-status=live }}</ref> ''PackageCompiler.jl'' can build standalone [[executable]]s that need no Julia source code to run.<ref name="PackageCompiler.jl">{{Cite web|title=GitHub - JuliaLang/PackageCompiler.jl: Compile your Julia Package.|date=2019-02-14|url=https://github.com/JuliaLang/PackageCompiler.jl|publisher=The Julia Language|access-date=2019-02-15|archive-date=23 March 2019|archive-url=https://web.archive.org/web/20190323182857/https://github.com/JuliaLang/PackageCompiler.jl|url-status=live}}</ref>
 
In Julia, everything is an object, much like object-oriented languages; however, unlike most object-oriented languages, all functions use [[multiple dispatch]] to select methods, rather than single dispatch.
 
Most programming paradigms can be implemented using Julia's [[homoiconicity|homoiconic]] macros and packages. Julia's [[Macro (computer science)#Syntactic macros|syntactic macros]] (used for [[metaprogramming]]), like Lisp macros, are more powerful than [[Macro (computer science)#Text-substitution macros|text-substitution macros]] used in the [[preprocessor]] of some other languages such as C, because they work at the level of [[abstract syntax tree]]s (ASTs). Julia's macro system is [[hygienic macro|hygienic]], but also supports deliberate capture when desired (like for [[anaphoric macro]]s) using the <code>esc</code> construct.
 
Julia draws inspiration from various dialects of Lisp, including [[Scheme (programming language)|Scheme]] and [[Common Lisp]], and it shares many features with [[Dylan (programming language)|Dylan]], also a multiple-dispatch-oriented dynamic language (which features an [[infix notation|infix]] syntax rather than a Lisp-like prefix syntax, while in Julia "everything"<ref name="Learn Julia in Y">{{Cite web |url=https://learnxinyminutes.com/docs/julia/ |title=Learn Julia in Y Minutes |website=Learnxinyminutes.com |access-date=2017-05-31 |archive-date=15 August 2018 |archive-url=https://web.archive.org/web/20180815232855/https://learnxinyminutes.com/docs/julia/ |url-status=live }}</ref> is an [[expression (computer science)|expression]]), and with [[Fortress (programming language)|Fortress]], another numerical programming language (which features multiple dispatch and a sophisticated parametric type system). While [[Common Lisp Object System]] (CLOS) adds multiple dispatch to Common Lisp, not all functions are generic functions.
 
In Julia, Dylan, and Fortress, extensibility is the default, and the system's built-in functions are all generic and extensible. In Dylan, multiple dispatch is as fundamental as it is in Julia: all user-defined functions and even basic built-in operations like <code>+</code> are generic. Dylan's type system, however, does not fully support parametric types, which are more typical of the [[generational list of programming languages#ML based|ML lineage of languages]]. By default, CLOS does not allow for dispatch on Common Lisp's parametric types; such extended dispatch semantics can only be added as an extension through the [[Common Lisp Object System#Metaobject Protocol|CLOS Metaobject Protocol]]. By convergent design, Fortress also features multiple dispatch on parametric types; unlike Julia, however, Fortress is statically rather than dynamically typed, with separate compiling and executing phases. The language features are summarized in the following table:
 
{| class="wikitable"
|-
! [[Programming language|Language]] !! [[Type system]] !! [[Generic function]]s !! [[Parametric polymorphism|Parametric types]]
|-
| Julia || Dynamic || Default || {{Yes}}
|-
| [[Common Lisp]] || Dynamic || Opt-in || {{Yes2|Yes (but no dispatch)}}
|-
| [[Dylan (programming language)|Dylan]] || Dynamic || Default || {{Partial}} (no dispatch)
|-
| [[Fortress (programming language)|Fortress]] || Static || Default || {{Yes}}
|}
 
An example of the extensibility of Julia, the ''Unitful.jl'' package adds support for physical [[unit of measurement|units of measurement]] to the language.
 
===Interoperability===
Julia has built-in support for calling [[C (programming language)|C]] or [[Fortran]] language libraries using the <syntaxhighlight lang="julia" inline="">@ccall</syntaxhighlight> macro. Additional libraries allow users to call to or from other languages such as [[Python (programming language)|Python]],<ref>{{Cite web |title=PythonCall & JuliaCall |date=2023-10-29 |url=https://github.com/JuliaPy/PythonCall.jl |access-date=2023-10-30 |publisher=JuliaPy |archive-date=31 October 2023 |archive-url=https://web.archive.org/web/20231031010517/https://github.com/JuliaPy/PythonCall.jl |url-status=live }}</ref> [[C++]],<ref>{{Cite web |last=Cords |first=Clem |title=Clemapfel/jluna |website=[[GitHub]] |date=2024-11-12 |url=https://github.com/Clemapfel/jluna |access-date=2024-11-26}}</ref><ref>{{Cite web |title=CxxWrap |date=2023-10-28 |url=https://github.com/JuliaInterop/CxxWrap.jl |access-date=2023-10-30 |publisher=JuliaInterop}}</ref> [[Rust (programming language)|Rust]], [[R (programming language)|R]],<ref>{{Cite web |title=RCall.jl |date=2023-10-16 |url=https://github.com/JuliaInterop/RCall.jl |access-date=2023-10-30 |publisher=JuliaInterop |archive-date=30 April 2019 |archive-url=https://web.archive.org/web/20190430053549/https://github.com/JuliaInterop/RCall.jl |url-status=live }}</ref> [[Java (programming language)|Java]]<ref>{{Cite news |date=2020-06-02 |title=Julia and Spark, Better Together |url=https://juliacomputing.com/blog/2020/06/02/julia-spark.html |archive-url=https://web.archive.org/web/20200714205019/https://juliacomputing.com/blog/2020/06/02/julia-spark.html |archive-date=14 July 2020 |website=juliacomputing.com}}</ref> and to use with [[SQL]].<ref>{{Cite web |last=Foster |first=Claire |title=SQLREPL.jl |website=[[GitHub]] |date=2023-10-23 |url=https://github.com/c42f/SQLREPL.jl |access-date=2023-10-31 |archive-date=27 September 2022 |archive-url=https://web.archive.org/web/20220927085821/https://github.com/c42f/SQLREPL.jl |url-status=live }}</ref><ref>{{Cite web |last=Noh |first=WooKyoung |title=Octo.jl |website=[[GitHub]] |date=2023-10-18 |url=https://github.com/wookay/Octo.jl |access-date=2023-10-31}}</ref><ref>{{Cite web |title=Usage Guide · FunSQL.jl |url=https://mechanicalrabbit.github.io/FunSQL.jl/stable/guide/#Why-FunSQL? |access-date=2023-10-31 |website=mechanicalrabbit.github.io |archive-date=31 October 2023 |archive-url=https://web.archive.org/web/20231031175900/https://mechanicalrabbit.github.io/FunSQL.jl/stable/guide/#Why-FunSQL? |url-status=live }}</ref><ref>{{Cite web |date=21 October 2022 |title=Using Julia with Oracle Databases |url=https://blogs.oracle.com/timesten/post/using-julia-with-oracle-database |access-date=8 November 2022 |archive-date=8 November 2022 |archive-url=https://web.archive.org/web/20221108125241/https://blogs.oracle.com/timesten/post/using-julia-with-oracle-database |url-status=live }}</ref>
 
===Separately-compiled executables option===
Julia can be compiled to binary [[executable]]s with ''PackageCompiler.jl''.<ref name="PackageCompiler.jl" /> Smaller executables can also be written using a static subset of the language provided by ''StaticCompiler.jl'' that does not support [[runtime dispatch]] (nor garbage collection, since excludes the runtime that provides it).<ref>{{Cite web |last=Short |first=Tom |title=StaticCompiler |website=[[GitHub]] |date=2023-10-30 |url=https://github.com/tshort/StaticCompiler.jl |access-date=2023-10-30 |archive-date=31 October 2023 |archive-url=https://web.archive.org/web/20231031010517/https://github.com/tshort/StaticCompiler.jl |url-status=live }}</ref>
 
==Interaction==
The Julia official distribution includes an interactive command-line [[read–eval–print loop]] (REPL),<ref>{{Cite web|url=https://docs.julialang.org/en/v1/stdlib/REPL/|title=The Julia REPL · The Julia Language|website=docs.julialang.org|access-date=2019-09-22|archive-date=22 September 2019|archive-url=https://web.archive.org/web/20190922175929/https://docs.julialang.org/en/v1/stdlib/REPL/|url-status=live}}</ref> with a searchable history, [[command-line completion|tab completion]], and dedicated help and [[shell (computing)|shell]] modes,<ref>{{Cite web|url=https://en.wikibooks.org/wiki/Introducing_Julia/The_REPL|title=Introducing Julia/The REPL - Wikibooks, open books for an open world|website=en.wikibooks.org|quote=you can install the Julia package OhMyREPL.jl [..] which lets you customize the REPL's appearance and behaviour|access-date=2019-09-22|archive-date=23 June 2019|archive-url=https://web.archive.org/web/20190623142710/https://en.wikibooks.org/wiki/Introducing_Julia/The_REPL|url-status=live}}</ref> which can be used to experiment and test code quickly.<ref>{{Cite web|url=https://docs.julialang.org/en/v1/manual/getting-started/|title=Getting Started · The Julia Language|website=docs.julialang.org|language=en|access-date=2018-08-15|archive-date=10 August 2019|archive-url=https://web.archive.org/web/20190810173026/https://docs.julialang.org/en/v1/manual/getting-started/|url-status=live}}</ref> The following fragment represents a sample session example where strings are concatenated automatically by <code>println</code>:<ref>See also: {{URL|https://docs.julialang.org/en/v1/manual/strings/}} for string interpolation and the <code>string(greet, ", ", whom, ".\n")</code> example for preferred ways to concatenate strings. <!--While the <code>+</code> operator is not used for string concatenation, it could easily be defined to do so.--> Julia has the println and print functions, but also a @printf macro (i.e., not in function form) to eliminate run-time overhead of formatting (unlike the same function in C).</ref>
 
<syntaxhighlight lang="jlcon">
julia> p(x) = 2x^2 + 1; f(x, y) = 1 + 2p(x)y
julia> println("Hello world!", " I'm on cloud ", f(0, 4), " as Julia supports recognizable syntax!")
Hello world! I'm on cloud 9 as Julia supports recognizable syntax!
</syntaxhighlight>
 
The REPL gives user access to the system shell and to help mode, by pressing <code>;</code> or <code>?</code> after the prompt (preceding each command), respectively. It also keeps the history of commands, including between sessions.<ref>{{Cite web|title=Julia Documentation|url=https://docs.julialang.org/|website=JuliaLang.org|access-date=18 November 2014|archive-date=17 December 2016|archive-url=https://web.archive.org/web/20161217182748/http://docs.julialang.org/|url-status=live}}</ref> Code can be tested inside Julia's interactive session or saved into a file with a <code>.jl</code> extension and run from the command line by typing:<ref name="Learn Julia in Y"/>
 
<syntaxhighlight lang="console">
$ julia <filename>
</syntaxhighlight>
 
Julia uses [[UTF-8]] and [[LaTeX]] codes, allowing it to support common math symbols for many operators, such as ∈ for the <code>in</code> operator, typable with <code>\in</code> then pressing {{keypress|TAB}} (i.e. uses [[LaTeX]] codes, or also possible by simply copy-pasting, e.g. {{not a typo|√ and ∛}} possible for [[square root|sqrt]] and [[cube root|cbrt]] functions). Julia has support for [[Unicode]] 15.1 (Julia&nbsp;1.12.0-rc1<!-- and alpha1 --> supports latest 16.0 release<ref>{{Cite web |title=support Unicode 16 via utf8proc 2.10.0 by stevengj · Pull Request #56925 · JuliaLang/julia |url=https://github.com/JuliaLang/julia/pull/56925 |access-date=2025-01-08 |website=GitHub |language=en}}</ref>) for the languages of the world, even for source code, e.g. variable names (while it's recommended to use English for public code, and e.g. package names).
 
Julia is supported by ''[[Project Jupyter|Jupyter]]'', an online interactive "notebooks" environment,<ref>{{Cite web |url=https://jupyter.org/ |title=Project Jupyter |access-date=19 August 2015 |archive-date=29 June 2017 |archive-url=https://web.archive.org/web/20170629054445/https://jupyter.org/ |url-status=live }}</ref> and ''[https://github.com/fonsp/Pluto.jl Pluto.jl]'', a "reactive notebook" (where notebooks are saved as pure Julia files), a possible replacement for the former kind.<ref>{{Cite web|last=Boudreau|first=Emmett|date=2020-10-16|title=Could Pluto Be A Real Jupyter Replacement?|url=https://towardsdatascience.com/could-pluto-be-a-real-jupyter-replacement-6574bfb40cc6|access-date=2020-12-08|website=Medium|language=en|archive-date=12 April 2023|archive-url=https://web.archive.org/web/20230412112240/https://towardsdatascience.com/could-pluto-be-a-real-jupyter-replacement-6574bfb40cc6|url-status=live}}</ref> In addition Posit's (formerly [[RStudio]] Inc's) Quarto publishing system supports Julia, Python, R and Observable [[JavaScript]] (those languages have official support by the company, and can even be weaved together in the same notebook document, more languages are unofficially supported).<ref>{{Cite web |last=Machlis |first=Sharon |date=2022-07-27 |title=RStudio changes name to Posit, expands focus to include Python and VS Code |url=https://www.infoworld.com/article/3668252/rstudio-changes-name-to-posit-expands-focus-to-include-python-and-vs-code.html |access-date=2023-01-18 |website=InfoWorld |language=en}}</ref><ref>{{Cite web |date=2022-07-20 |title=Heads up! Quarto is here to stay. Immediately combine R & Python in your next document: An extension on a recent post. |url=https://www.ds-econ.com/quarto/ |access-date=2023-01-18 |website=ds-econ |language=en |archive-date=31 January 2023 |archive-url=https://web.archive.org/web/20230131161337/https://www.ds-econ.com/quarto/ |url-status=usurped }}</ref>
 
The REPL can be extended with additional modes, and has been with packages, e.g. with an [[SQL]] mode,<ref>{{Cite web |first=Chris |last=Foster |title=SQLREPL.jl |website=[[GitHub]] |date=2022-04-04 |url=https://github.com/c42f/SQLREPL.jl |access-date=2022-09-27 |archive-date=27 September 2022 |archive-url=https://web.archive.org/web/20220927085821/https://github.com/c42f/SQLREPL.jl |url-status=live }}</ref> for database access, and ''RCall.jl'' adds an {{nowrap|R mode}}, to work with the [[R (programming language)|R language]].<ref>{{Cite web |title=Getting Started · RCall.jl |url=https://juliainterop.github.io/RCall.jl/latest/gettingstarted.html#Several-Ways-to-use-RCall-1 |access-date=2022-09-27 |website=juliainterop.github.io |archive-date=4 September 2024 |archive-url=https://web.archive.org/web/20240904035201/https://juliainterop.github.io/RCall.jl/latest/gettingstarted.html#Several-Ways-to-use-RCall-1 |url-status=live }}</ref>
 
Julia's [[Visual Studio Code]] extension provides a fully featured [[integrated development environment]] with "built-in dynamic autocompletion, inline results, plot pane, integrated REPL, variable view, code navigation, and many other advanced language features"<ref>{{Cite news |title=Julia in Visual Studio Code |url=https://code.visualstudio.com/docs/languages/julia}}</ref> e.g. debugging is possible, [[lint (software)|linting]], and [[profiling (computer programming)|profiling]].<ref>{{Cite web|last=Holy|first=Tim|title=GitHub - timholy/ProfileView.jl: Visualization of Julia profiling data.|website=[[GitHub]]|date=2019-09-13|url=https://github.com/timholy/ProfileView.jl|access-date=2019-09-22|archive-date=31 January 2020|archive-url=https://web.archive.org/web/20200131231452/https://github.com/timholy/ProfileView.jl|url-status=live}}</ref><ref>{{Cite web|last=Gregg|first=Brendan|title=GitHub - brendangregg/FlameGraph: Stack trace visualizer.|website=[[GitHub]]|date=2019-09-20|url=https://github.com/brendangregg/FlameGraph|access-date=2019-09-22|archive-date=26 September 2019|archive-url=https://web.archive.org/web/20190926230048/https://github.com/brendangregg/FlameGraph|url-status=live}}</ref><ref>{{Cite web|url=https://julialang.org/blog/2019/03/debuggers|title=A Julia interpreter and debugger|website=julialang.org|access-date=2019-04-10}}</ref><ref>{{Cite web|url=https://timholy.github.io/Rebugger.jl/dev/|title=Home · Rebugger.jl|website=timholy.github.io|access-date=2019-04-10|archive-date=31 March 2019|archive-url=https://web.archive.org/web/20190331171846/https://timholy.github.io/Rebugger.jl/dev/|url-status=live}}</ref>
 
===Use with other languages===
Julia is in practice [[interoperability|interoperable]] with other languages, in fact the majority of the top 20 languages in popular use. Julia can be used to call shared library functions individually, such as those written in C or Fortran, and packages are available to allow calling other languages (which do not provide C-exported functions directly), e.g. Python (with ''PythonCall.jl''), R<!-- Works with 1.11.x (and 1.10.5 presumably too, but not for all) for at least some users, unclear why not for all, user on discource confimed worked on macOS, and I on Linux. -->,<ref>{{Cite web |date=2024-10-21 |title=Julia crashes on installation of the RCall module |url=https://discourse.julialang.org/t/julia-crashes-on-installation-of-the-rcall-module/121560/6 |access-date=2024-10-22 |website=Julia Programming Language |language=en |quote=For me RCall loads without issue on Julia 1.11 on MacOS}}</ref> MATLAB, C# (and other .NET languages with ''DotNET.jl'', from them with ''JdotNET''), JavaScript, Java (and other JVM languages, such as [[Scala (programming language)|Scala]] with ''JavaCall.jl''). And packages for other languages allow to call to Julia, e.g. from Python, R (to Julia 1.10.x currently possible<!--JuliaCall/r-juliacall likely used an internal/"non-public", non-API, though exported, since removed, i.e. the package was broken by Julia 1.11; the fix is trivial, though the maintainer absent, and I've suggested a workaround, *other* package to call from R to Julia should work for Julia 1.11 still. ---><ref>{{Cite web |title=juliacall fails in julia 1.11 with 'undefined symbol: jl_stdout_obj' · Issue #234 · Non-Contradiction/JuliaCall |url=https://github.com/Non-Contradiction/JuliaCall/issues/234 |access-date=2024-10-22 |website=GitHub |language=en}}</ref>), [[Rust (programming language)|Rust]], Ruby, or C#. Such as with juliacall (part of ''PythonCall.jl''<!-- , pyjulia is a different option -->) to call from Python and a different ''JuliaCall'' package for calling, Julia up to 1.10.x, from R. Julia has also been used for hardware, i.e. to compile to [[VHDL]], as a [[high-level synthesis]] tool, for example [[field-programmable gate array|FPGA]]s.<ref name="HLS/FPGA" />
 
Julia has packages supporting markup languages such as [[HTML]] (and also for [[HTTP]]), [[XML]], [[JSON]] and [[BSON]], and for [[database]]s (such as PostgreSQL,<ref>{{Cite web |title=Home · LibPQ.jl |url=https://invenia.github.io/LibPQ.jl/stable/ |access-date=2022-11-08 |website=invenia.github.io |archive-date=8 November 2022 |archive-url=https://web.archive.org/web/20221108125236/https://invenia.github.io/LibPQ.jl/stable/ |url-status=dead }}</ref> Mongo,<ref name="FunSQL" /> Oracle, including for [[TimesTen]],<ref>{{Cite web |last=Hood |first=Doug |date=21 October 2022 |title=Using Julia with Oracle Databases |url=https://blogs.oracle.com/timesten/post/using-julia-with-oracle-database |access-date=8 November 2022 |archive-date=8 November 2022 |archive-url=https://web.archive.org/web/20221108125241/https://blogs.oracle.com/timesten/post/using-julia-with-oracle-database |url-status=live }}</ref> MySQL, SQLite, Microsoft SQL Server,<ref name="FunSQL">{{Cite web |title=Home · FunSQL.jl |url=https://docs.juliahub.com/FunSQL/HGzDG/0.9.2/ |access-date=2022-11-08 |website=docs.juliahub.com |archive-date=8 November 2022 |archive-url=https://web.archive.org/web/20221108125240/https://docs.juliahub.com/FunSQL/HGzDG/0.9.2/ |url-status=live }}</ref> Amazon Redshift, Vertica, ODBC) and web use in general.<ref>{{Cite web |title=Genie Builder - Visual Studio Marketplace |url=https://marketplace.visualstudio.com/items?itemName=GenieBuilder.geniebuilder |access-date=2022-11-08 |website=marketplace.visualstudio.com |language=en-us |archive-date=8 November 2022 |archive-url=https://web.archive.org/web/20221108123305/https://marketplace.visualstudio.com/items?itemName=GenieBuilder.geniebuilder |url-status=live }}</ref><ref>{{Cite web |date=2022-02-01 |title=How to Build Your First Web App in Julia with Genie.jl |url=https://www.freecodecamp.org/news/how-to-build-web-apps-in-julia/ |access-date=2022-11-08 |website=freeCodeCamp.org |language=en |archive-date=8 November 2022 |archive-url=https://web.archive.org/web/20221108123305/https://www.freecodecamp.org/news/how-to-build-web-apps-in-julia/ |url-status=live }}</ref>
 
==Package system==
Julia has a built-in [[package manager]] and includes a default registry system.<ref>{{Cite web|url=https://github.com/JuliaRegistries/General|title=JuliaRegistries / General|website=[[GitHub]]|access-date=2020-04-30|archive-date=3 August 2020|archive-url=https://web.archive.org/web/20200803230347/https://github.com/JuliaRegistries/General|url-status=live}}</ref> Packages are most often distributed as source code hosted on [[GitHub]], though alternatives can also be used just as well. Packages can also be installed as binaries, using artifacts.<ref>{{Cite web|url=https://julialang.github.io/Pkg.jl/dev/artifacts/|title=Pkg.jl - Artifacts|access-date=2020-06-04|archive-date=2 August 2020|archive-url=https://web.archive.org/web/20200802205207/https://julialang.github.io/Pkg.jl/dev/artifacts/|url-status=live}}</ref> Julia's package manager is used to query and compile packages, as well as managing environments. Federated package registries are supported, allowing registries other than the official to be added locally.<ref>{{Cite web|url=https://julialang.github.io/Pkg.jl/v1/registries/|title=Pkg.jl - Registries|access-date=2020-04-30|archive-date=13 June 2020|archive-url=https://web.archive.org/web/20200613144113/https://julialang.github.io/Pkg.jl/v1/registries/|url-status=live}}</ref>
 
==Implementation==
Julia's core is implemented in Julia and [[C (programming language)|C]],<!-- C99, except for 0.4 needing C11 because of static asserts --> together with [[C++]] for the [[LLVM]] dependency. The code parsing, code-lowering, and bootstrapping were implemented in FemtoLisp, a [[Scheme (programming language)|Scheme]] dialect, up to version 1.10.<ref name="JeffBezanson 2019">{{Cite web | first=Jeff | last=Bezanson | title=JeffBezanson/femtolisp | website=GitHub | date=6 June 2019 | url=https://github.com/JeffBezanson/femtolisp | access-date=16 June 2019 | archive-date=22 December 2022 | archive-url=https://web.archive.org/web/20221222170835/https://github.com/JeffBezanson/femtolisp | url-status=live }}</ref> Since that version the new pure-Julia stdlib package ''JuliaSyntax.jl'' is used for the parsing (while the old one can still be chosen)<ref>{{Cite web |title=JuliaSyntax |date=2022-08-28 |url=https://github.com/JuliaLang/JuliaSyntax.jl |publisher=The Julia Programming Language |access-date=2022-08-28 |archive-date=28 August 2022 |archive-url=https://web.archive.org/web/20220828185806/https://github.com/JuliaLang/JuliaSyntax.jl |url-status=live }}</ref> which improves speed and "greatly improves parser error messages in various cases".<ref>{{Cite web |title=Enable JuliaSyntax.jl as an alternative Julia parser by c42f · Pull Request #46372 · JuliaLang/julia |url=https://github.com/JuliaLang/julia/pull/46372 |access-date=2022-08-28 |website=GitHub |language=en |archive-date=28 August 2022 |archive-url=https://web.archive.org/web/20220828185805/https://github.com/JuliaLang/julia/pull/46372 |url-status=live }}</ref> The LLVM compiler infrastructure project is used as the [[Compiler#Back end|back end]] for generating optimized [[machine code]] for all commonly used platforms. With some exceptions, the [[standard library]] is implemented in Julia.
 
===Current and future platforms===
Julia has tier 1 [[macOS]] support, for 64-bit [[Apple Silicon]] Macs, natively (previously such [[Apple M1]]-based Macs were only supported by ''running in [[Rosetta 2]] emulation''<ref name="Apple Silicon">{{Cite web |date=2022-05-25 |title=Julia v1.7.3 has been released |url=https://discourse.julialang.org/t/julia-v1-7-3-has-been-released/81683 |access-date=2022-05-26 |website=JuliaLang |language=en |archive-date=26 May 2022 |archive-url=https://web.archive.org/web/20220526015606/https://discourse.julialang.org/t/julia-v1-7-3-has-been-released/81683 |url-status=live }}</ref><ref>{{Cite web|title=Darwin/ARM64 tracking issue · Issue #36617 · JuliaLang/julia|url=https://github.com/JuliaLang/julia/issues/36617|access-date=2020-12-08|website=GitHub|language=en|archive-date=11 November 2020|archive-url=https://web.archive.org/web/20201111014801/https://github.com/JuliaLang/julia/issues/36617|url-status=live}}</ref>), and also fully supports Intel-based Macs. [[Windows 10|Windows on ARM]] has no official support yet. OpenBSD has received "initial support" and is under active development.
 
Julia has four support tiers.<ref>{{Cite web|url=https://julialang.org/downloads/#support-tiers|title=Julia Downloads|website=julialang.org|access-date=2019-05-17|archive-date=26 January 2021|archive-url=https://web.archive.org/web/20210126095723/https://julialang.org/downloads/#support-tiers|url-status=live}}</ref> All [[IA-32]] processors completely implementing the [[P6 (microarchitecture)|i686]] subarchitecture are supported and all 64-bit [[x86-64]] (aka [[amd64]]), i.e. all less than about a decade old are supported. 64-bit [[Armv8]] (and later; i.e. [[AArch64]]) processors are supported on first tier (for macOS); otherwise second tier on Linux, and ARMv7 (AArch32) on third tier<!-- , and ARMv6 were known to work with some caveats in Julia&nbsp;1.0.x -->.<ref>{{Cite web |title=julia/arm.md |date=2021-10-07 |url=https://github.com/JuliaLang/julia/blob/master/doc/src/devdocs/build/arm.md |publisher=The Julia Language |quote=A list of known issues for ARM is available. |access-date=2022-05-15 |archive-date=15 May 2022 |archive-url=https://web.archive.org/web/20220515202910/https://github.com/JuliaLang/julia/blob/master/doc/src/devdocs/build/arm.md |url-status=live }}</ref> Hundreds of packages are [[general-purpose computing on graphics processing units|GPU-accelerated]]:<ref>{{Cite web |title=JuliaGPU |url=https://juliagpu.org/ |access-date=2022-11-16 |website=juliagpu.org |quote=Almost 300 packages rely directly or indirectly on Julia's GPU capabilities. |archive-date=23 May 2020 |archive-url=https://web.archive.org/web/20200523103259/https://juliagpu.org/ |url-status=live }}</ref> Nvidia GPUs have support with ''[[CUDA]].jl'' (tier 1 on 64-bit Linux and tier 2 on 64-bit Windows, the package implementing [[Parallel Thread Execution|PTX]], for compute capability 3.5 (Kepler) or higher; both require CUDA 11+, older package versions work down to CUDA 9). There are also additionally packages supporting other accelerators, such as Google's [[tensor processing unit|TPU]]s,<ref>{{Cite web|title=Julia on TPUs|date=2019-11-26|url=https://github.com/JuliaTPU/XLA.jl|publisher=JuliaTPU|access-date=2019-11-29|archive-date=30 April 2019|archive-url=https://web.archive.org/web/20190430044159/https://github.com/JuliaTPU/XLA.jl|url-status=live}}</ref> and some Intel (integrated) GPUs, through ''[[oneAPI (compute acceleration)|oneAPI.jl]]'',<ref>{{Cite web|title=Introducing: oneAPI.jl ⋅ JuliaGPU|url=https://juliagpu.org/post/2020-11-05-oneapi_0.1/|access-date=2021-09-06|website=juliagpu.org}}</ref> and AMD's GPUs have support with e.g. [[OpenCL]]; and experimental support for the AMD [[ROCm]] stack.<ref>{{Cite web|url=https://juliagpu.org/rocm/|title=AMD ROCm · JuliaGPU|website=juliagpu.org|access-date=2020-04-20|archive-date=13 June 2020|archive-url=https://web.archive.org/web/20200613154944/https://juliagpu.org/rocm/|url-status=live}}</ref>
<!--
Julia has been built on the following ARMv8 devices:
 
* [https://www.nvidia.com/object/embedded-systems-dev-kits-modules.html nVidia Jetson TX1 & TX2];
* [https://www.apm.com/products/data-center/x-gene-family/x-gene/ X-Gene 1];
* [https://softiron.com/products/overdrive-3000/ Overdrive 3000];
* [https://www.cavium.com/ThunderX_ARM_Processors.html Cavium ThunderX]-->
 
for several ARM platforms, from small Raspberry Pis to the world's fastest (at one point, until recently) supercomputer [[Fugaku (supercomputer)|Fugaku]]'s ARM-based [[Fujitsu A64FX|A64FX]].<ref>{{Cite web |last=Giordano |first=Mosè |title=Julia on Fugaku (2022-07-23) |website=[[GitHub]] |date=2022-09-29 |url=https://github.com/giordano/julia-on-fugaku |access-date=2022-11-08 |archive-date=8 November 2022 |archive-url=https://web.archive.org/web/20221108120723/https://github.com/giordano/julia-on-fugaku |url-status=live }}</ref> [[Power Architecture|<!--- meaning [[POWER8]], but shown as: -->PowerPC]] [[little endian|LE]] (64-bit) has tier&nbsp;3 support, meaning it "may or may not build", and its tier will lower to 4 for 1.12, i.e. then no longer builds/works.<ref>{{Cite web |date=2025-02-18 |title=PowerPC will be demoted to Tier 4 in Julia 1.12 and later |url=https://discourse.julialang.org/t/powerpc-will-be-demoted-to-tier-4-in-julia-1-12-and-later/122923/4 |access-date=2025-02-23 |website=Julia Programming Language |language=en}}</ref>
<!--
Support for ARM and [[AArch64]] was added as of 0.5.1.<ref>{{Cite web|url=https://github.com/JuliaLang/julia/blob/v0.5.2/README.md |title=julia/README.md at v0.5.2 · JuliaLang/julia · GitHub |website=Github.com |date=2017-05-03 |access-date=2017-05-31}}</ref>
 
and in 0.5.x:
 
"work in progress" text dropped with (not yet backported (possibly the text, only docs left behind?) to 0.6.x): https://github.com/JuliaLang/julia/commit/dcffef03594779402bb5c2666fbcf24b4438adba#diff-8b8b297c5626992d7377a6bbb3aadceb
 
"only supports ARMv7" text dropped on master (may apply on older, meaning possibly only for ARMv6?:
 
"[[Nightly build]]s are available for ARMv7-A. [..] Note that OpenBLAS only supports ARMv7. For older ARM variants, using the reference BLAS may be the simplest thing to do. [..] Note: These [Raspberry Pi] chips use ARMv6, which is not well supported at the moment. However it is possible to get a working Julia build. [e.g., supported] [[Tegra#Tegra P1|nVidia Jetson TX2]] [with] CUDA functionality"<ref>{{Cite web|publisher=JuliaLang |url=https://github.com/JuliaLang/julia/blob/v0.6.2/README.arm.md |title=julia/README.arm.md at v0.5.2 · JuliaLang/julia · GitHub |website=Github.com |access-date=2017-05-31}}</ref>
-->
 
Julia has official (tier 2) support for 64-bit ARMv8 meaning e.g. newer 64-bit (ARMv8-A) [[Raspberry Pi]] computers work with Julia (e.g. the Pi Compute Module 4 has been used in space running Julia code).<ref name="space_GPS" /> For many Pis, especially older 32-bit ones, it helps to cross-compile the user's Julia code for them. The older 32-bit ARMv7 Pis worked in older Julia versions (still do, but for latest Julia version(s), note downgraded from tier 3 to its current tier 4: "Julia built at some point in the past, but is known not to build currently."). The original [[Raspberry Pi]] 1 has no official support (since it uses [[ARMv6]] which has newer had a support tier; though some cut-down Julia <!-- i.e. missing OpenBLAS, that has a replacement --> has been known to run on that Pi).<ref>{{Cite web |url=https://github.com/JuliaLang/julia/issues/10488
|title=Cross-compiling for ARMv6
|quote=I believe #10917 should fix this. The CPU used there <code>arm1176jzf-s</code>. Please reopen if it does not.
|access-date=16 May 2015}}
</ref><ref>
{{Cite web |url=https://github.com/JuliaLang/julia/issues/10235
|title=ARM build failing during bootstrap on Raspberry Pi 2
|quote=I can confirm (FINALLY) that it works on the Raspberry Pi 2 [..] I guess we can announce alpha support for arm in 0.4 as well. |access-date=16 May 2015}}</ref>
Pico versions of the Pi are known to no work (since using the M-profile Arm, not running under Linux; not yet supported). Julia is now supported in [[Raspbian]]<ref>{{Cite web |url=https://julialang.org/blog/2017/05/raspberry-pi-julia |title=Julia available in Raspbian on the Raspberry Pi |quote=Julia works on all the Pi variants, we recommend using the Pi 3. |access-date=6 June 2017 |archive-date=4 May 2017 |archive-url=https://web.archive.org/web/20170504162102/https://julialang.org/blog/2017/05/raspberry-pi-julia |url-status=live }}</ref> while support is better for newer Pis, e.g., those with Armv7 or newer; the Julia support is promoted by the [[Raspberry Pi Foundation]].<ref>{{Cite web |url=https://www.raspberrypi.org/blog/julia-language-raspberry-pi/ |title=Julia language for Raspberry Pi |work=[[Raspberry Pi Foundation]] |date=12 May 2017 |access-date=6 June 2017 |archive-date=2 June 2017 |archive-url=https://web.archive.org/web/20170602144753/https://www.raspberrypi.org/blog/julia-language-raspberry-pi/ |url-status=live }}</ref>
 
On some platforms, Julia may need to be compiled from source code (e.g., the original [[Raspberry Pi]]), with specific build options, which has been done and unofficial pre-built binaries (and build instructions) are available.<ref>{{Cite web|title=Build Julia for RaspberryPi Zero|url=https://gist.github.com/terasakisatoshi/3f8a55391b1fc22a5db4a43da8d92c98|access-date=2020-08-14|website=Gist|language=en|archive-date=1 December 2020|archive-url=https://web.archive.org/web/20201201075252/https://gist.github.com/terasakisatoshi/3f8a55391b1fc22a5db4a43da8d92c98|url-status=live}}</ref><ref>{{Cite web|title=JuliaBerry: Julia on the Raspberry Pi|url=https://juliaberry.github.io/|access-date=2020-08-14|website=juliaberry.github.io|archive-date=8 July 2020|archive-url=https://web.archive.org/web/20200708065730/https://juliaberry.github.io/|url-status=live}}</ref>
 
Julia has also been built for 64-bit [[RISC-V]] (has tier 3 support),<ref>{{Cite web |title=Release v1.12-0a92fecc12 · maleadt/julia |url=https://github.com/maleadt/julia/releases/tag/v1.12-0a92fecc12 |access-date=2024-10-12 |website=GitHub |language=en}}</ref><ref>{{Cite web |title=julia/doc/src/devdocs/build/riscv.md at master · alexfanqi/julia |url=https://github.com/alexfanqi/julia/blob/master/doc/src/devdocs/build/riscv.md |access-date=2024-10-09 |website=GitHub |language=en}}</ref> i.e. has some supporting code in core Julia.
 
While Julia requires an [[operating system]] by default, and has no official support to run without, or on [[embedded system]] platforms such as [[Arduino]], Julia code has still been run on it, with some limitations, i.e. on a baremetal 16&nbsp;[[Hertz#Computers|MHz]] [[8-bit computing|8-bit]] ([[ATmega328P]]) [[AVR microcontrollers|AVR-microcontroller]] Arduino with 2&nbsp;KB RAM (plus 32&nbsp;KB of flash memory).<ref>{{Cite web |title=Running Julia baremetal on an Arduino |url=https://seelengrab.github.io/articles/Running%20Julia%20baremetal%20on%20an%20Arduino/ |access-date=2022-05-24 |website=seelengrab.github.io |archive-date=24 May 2022 |archive-url=https://web.archive.org/web/20220524075548/https://seelengrab.github.io/articles/Running%20Julia%20baremetal%20on%20an%20Arduino/ |url-status=live }}</ref><ref>{{Cite web |last=Sukera |title=AVRDevices.jl |website=[[GitHub]] |date=2023-07-31 |url=https://github.com/Seelengrab/AVRDevices.jl |access-date=2023-08-05 |archive-date=5 August 2023 |archive-url=https://web.archive.org/web/20230805203930/https://github.com/Seelengrab/AVRDevices.jl |url-status=live }}</ref>
 
==Adoption==
Julia has been adopted at many universities including [[MIT]], [[Stanford University|Stanford]], [[UC Berkeley]], [[Ferdowsi University of Mashhad]] and the [[University of Cape Town]]. Large private firms across many sectors have adopted the language including [[Amazon (company)|Amazon]], [[IBM]], [[JP Morgan]] AI Research,<ref>{{Cite web |last=Chen |first=Jiahao |title=Jiahao Chen |url=https://jiahao.github.io/ |access-date=2023-02-23 |website=Jiahao Chen |language=en-us |archive-date=23 February 2023 |archive-url=https://web.archive.org/web/20230223164307/https://jiahao.github.io/ |url-status=dead }}</ref> and [[ASML Holding|ASML]]. Julia has also been used by government agencies including [[NASA]] and the [[Federal Aviation Administration|FAA]], as well as every US national energy laboratory.<ref name=Fastest>{{Cite web |title='Why We Created Julia' Turns Ten Years Old |url=https://juliahub.com/company/media/2022/02/julia-turns-ten-years-old/ |access-date=2022-11-16 |website=juliahub.com |archive-date=16 November 2022 |archive-url=https://web.archive.org/web/20221116115921/https://juliahub.com/company/media/2022/02/julia-turns-ten-years-old/ |url-status=live }}</ref><ref>{{Cite web |title=Newsletter January 2022 - Julia Growth Statistics - Julia Computing |url=https://juliacomputing.com/blog/2022/01/newsletter-january/ |access-date=2022-01-26 |website=juliacomputing.com |language=en |archive-date=26 January 2022 |archive-url=https://web.archive.org/web/20220126104801/https://juliacomputing.com/blog/2022/01/newsletter-january/ |url-status=live }}</ref>
 
===Scientific computing and engineering===
* [[Amazon (company)|Amazon]], for [[quantum computing]]<ref>{{Cite web |title=Introducing Braket.jl - Quantum Computing with Julia |url=https://forem.julialang.org/kshyatt/introducing-braketjl-10f2 |access-date=2023-02-23 |website=Julia Community 🟣 |date=15 November 2022 |language=en |quote=Almost all of the Python SDK's features are reimplemented in Julia — for those few that aren't, we are also providing a subsidiary package, PyBraket.jl, which allows you to translate Julia objects into their Python equivalents and call the Python SDK. |archive-date=19 June 2024 |archive-url=https://web.archive.org/web/20240619193302/https://forem.julialang.org/kshyatt/introducing-braketjl-10f2 |url-status=live }}</ref> and [[machine learning]] through [[Amazon SageMaker]]<ref>{{Cite web |date=May 2020 |title=Getting started with Julia on Amazon SageMaker: Step-by-step Guide |url=https://d1.awsstatic.com/whitepapers/julia-on-sagemaker.pdf |access-date=23 February 2023 |archive-date=9 March 2024 |archive-url=https://web.archive.org/web/20240309071341/https://d1.awsstatic.com/whitepapers/julia-on-sagemaker.pdf |url-status=live }}</ref>
* [[ASML Holding|ASML]], for [[hard real-time]] programming with their machines<ref>{{Cite web |title=Towards Using Julia for Real-Time applications in ASML JuliaCon 2022 |url=https://pretalx.com/juliacon-2022/talk/GUQBSE/ |access-date=2023-02-23 |website=pretalx.com |date=27 July 2022 |language=en |archive-date=23 February 2023 |archive-url=https://web.archive.org/web/20230223164311/https://pretalx.com/juliacon-2022/talk/GUQBSE/ |url-status=live }}</ref>
* The Climate Modeling Alliance<ref>{{Cite web |title=Home - CliMA |url=https://clima.caltech.edu/ |website=CliMA – Climate Modeling Alliance |access-date=18 June 2023 |archive-date=18 June 2023 |archive-url=https://web.archive.org/web/20230618064622/https://clima.caltech.edu/ |url-status=live }}</ref> for climate change modeling<ref name="Julia_Nvidia">{{Cite press release |title=Julia Computing Brings Support for NVIDIA GPU Computing on Arm Powered Servers - JuliaHub |url=https://juliahub.com/blog/2019/12/nvidia-ngc-arm/ |access-date=2022-11-16 |website=juliahub.com |archive-date=16 November 2022 |archive-url=https://web.archive.org/web/20221116115917/https://juliahub.com/blog/2019/12/nvidia-ngc-arm/ |url-status=live }}</ref>
* [[CERN]], to analyze data from the [[Large Hadron Collider]] ([[LHCb experiment]])<ref>{{Cite web |date=27 September 2021 |title=Julia for HEP Mini-workshop |url=https://indico.cern.ch/event/1074269/ |access-date=2022-08-23 |website=indico.cern.c h |quote=Julia and the first observation of Ω<sup>−</sup>_b → Ξ<sup>+</sup>_c K<sup>−</sup> π<sup>−</sup> |archive-date=11 August 2022 |archive-url=https://web.archive.org/web/20220811180733/https://indico.cern.ch/event/1074269/ |url-status=live }}</ref><ref>{{Cite web |last=Mikhasenko |first=Misha |date=2022-07-29 |title=ThreeBodyDecay |url=https://github.com/mmikhasenko/ThreeBodyDecay.jl |access-date=2022-08-23 |website=[[GitHub]] |archive-date=23 August 2022 |archive-url=https://web.archive.org/web/20220823105223/https://github.com/mmikhasenko/ThreeBodyDecay.jl |url-status=live }}</ref><ref>{{Cite web |last=Mikhasenko |first=Misha |date=July 2021 |title=Julia for QCD spectroscopy |url=https://indico.cern.ch/event/1074269/contributions/4539610/attachments/2317472/3945345/spectroscopy_mmikhasenko.pdf |access-date=2022-08-23 |website=indico.cern.ch |quote=Summary: Julia is ready to be used in physics HEP analysis |archive-date=23 August 2022 |archive-url=https://web.archive.org/web/20220823100909/https://indico.cern.ch/event/1074269/contributions/4539610/attachments/2317472/3945345/spectroscopy_mmikhasenko.pdf |url-status=live }}.</ref><ref>{{Cite web |date=2022-08-19 |title=JuliaHEP/UnROOT.jl |url=https://github.com/JuliaHEP/UnROOT.jl |access-date=2022-08-23 |publisher=JuliaHEP |archive-date=19 June 2024 |archive-url=https://web.archive.org/web/20240619193142/https://github.com/JuliaHEP/UnROOT.jl |url-status=live }}</ref><ref>{{Cite web |title=Julia · Search · GitLab |url=https://gitlab.cern.ch/search?search=Julia&nav_source=navbar&project_id=741&group_id=635&scope=commits&repository_ref=master |access-date=2022-08-23 |website=GitLab |language=en |archive-date=23 August 2022 |archive-url=https://web.archive.org/web/20220823095642/https://gitlab.cern.ch/search?search=Julia&nav_source=navbar&project_id=741&group_id=635&scope=commits&repository_ref=master |url-status=live }}</ref><ref>{{Cite web |title=Commits · master · sft / lcgcmake · GitLab |url=https://gitlab.cern.ch/sft/lcgcmake/-/commits/master/cmake/toolchain/heptools-dev-base.cmake |access-date=2022-08-23 |website=GitLab |language=en |quote=bump julia version to 1.7.3 |archive-date=12 April 2023 |archive-url=https://web.archive.org/web/20230412113743/https://gitlab.cern.ch/sft/lcgcmake/-/commits/master/cmake/toolchain/heptools-dev-base.cmake |url-status=live }}</ref>
* NASA and the [[Jet Propulsion Laboratory]] use Julia to model spacecraft separation dynamics,<ref>{{Cite web |title=Modeling Spacecraft Separation Dynamics in Julia - Jonathan Diegelman | website=[[YouTube]] | date=9 March 2021 |url=https://www.youtube.com/watch?v=tQpqsmwlfY0 |language=en |access-date=2021-09-06 |archive-date=6 September 2021 |archive-url=https://web.archive.org/web/20210906221540/https://www.youtube.com/watch?v=tQpqsmwlfY0 |url-status=live }}</ref><ref>{{Cite web |title=Circuitscape/Circuitscape.jl |date=2020-02-25 |url=https://github.com/Circuitscape/Circuitscape.jl |publisher=Circuitscape |access-date=2020-05-26 |archive-date=30 July 2020 |archive-url=https://web.archive.org/web/20200730074511/https://github.com/Circuitscape/Circuitscape.jl |url-status=live }}</ref><ref>{{Cite web |title=Conservation through Coding: 5 Questions with Viral Shah {{!}} Science Mission Directorate |url=https://science.nasa.gov/earth-science/applied-sciences/making-space-for-earth/5-questions-with-viral-shah |access-date=2020-05-26 |website=science.nasa.gov |archive-date=25 May 2020 |archive-url=https://web.archive.org/web/20200525212814/https://science.nasa.gov/earth-science/applied-sciences/making-space-for-earth/5-questions-with-viral-shah |url-status=dead }}</ref> analyze [[TRAPPIST]] [[exoplanet]] datasets,<ref>{{Cite web |title=Julia in the Wild - Julia Data Science |url=https://juliadatascience.io/julia_wild |access-date=2022-09-12 |website=juliadatascience.io |archive-date=12 September 2022 |archive-url=https://web.archive.org/web/20220912202632/https://juliadatascience.io/julia_wild |url-status=live }}</ref><ref>{{Cite web |title=Seven Rocky TRAPPIST-1 Planets May Be Made of Similar Stuff |url=https://exoplanets.nasa.gov/news/1669/seven-rocky-trappist-1-planets-may-be-made-of-similar-stuff/ |access-date=2022-10-06 |website=Exoplanet Exploration: Planets Beyond our Solar System |date=21 January 2021 |archive-date=6 October 2022 |archive-url=https://web.archive.org/web/20221006193612/https://exoplanets.nasa.gov/news/1669/seven-rocky-trappist-1-planets-may-be-made-of-similar-stuff/ |url-status=live }}</ref> and analyze [[cosmic microwave background]] data from the [[Big Bang]]<ref>{{Cite web |title=Julia in Astronomy & Astrophysics Research {{!}} Eric B. Ford {{!}} JuliaCon 2022 | website=[[YouTube]] | date=25 July 2022 |url=https://www.youtube.com/watch?v=vj1uzilanQI |language=en |access-date=2022-10-06 |archive-date=6 October 2022 |archive-url=https://web.archive.org/web/20221006193235/https://www.youtube.com/watch?v=vj1uzilanQI |url-status=live }}</ref>
* The Brazilian [[National Institute for Space Research|INPE]], for space missions and [[satellite]] simulations<ref>{{Cite web |title=JuliaSpace/SatelliteToolbox.jl |date=2020-05-20 |url=https://github.com/JuliaSpace/SatelliteToolbox.jl |publisher=JuliaSpace |access-date=2020-05-26 |archive-date=16 June 2021 |archive-url=https://web.archive.org/web/20210616105212/https://github.com/JuliaSpace/SatelliteToolbox.jl |url-status=live }}</ref>
* Julia has also flown in space, on a small <!-- [[cubsat]] --> satellite,<ref name="space_GPS">{{Cite web |date=2024-12-13 |title=Julia and the GPS payload onboard Waratah Seed-1 satellite |url=https://discourse.julialang.org/t/julia-and-the-gps-payload-onboard-waratah-seed-1-satellite/123795 |access-date=2025-02-04 |website=Julia Programming Language |quote=We flew our GPS receiver payload, Harry v3 on Waratah Seed-1 6U cubesat [..] <!-- Julia running in space! --> Julia can also run on Raspberry Pi CM4, the processor I used on our GPS payload computer. <!-- [..] In space, we also capture IF data for us to do postprocessing in ground. --> |language=en}}</ref> used for a GPS module.<!-- https://www.reddit.com/r/Julia/comments/17vrk5r/what_are_the_most_fascinating_projects_you_have/ --> And Julia has also been used to design [[satellite constellation | satellite constellations]].<ref>{{Cite AV media |url=https://www.youtube.com/watch?v=2AfCljss-Lk |title=Designing satellites constellations with Julia {{!}} Clement de Givry {{!}} JuliaCon 2024 |date=2024-10-01 |last=The Julia Programming Language |access-date=2025-02-04 |via=YouTube}}</ref>
* [[Embedded system|Embedded]] hardware to plan and execute flight of autonomous U.S. [[Air Force Research Laboratory]] [[VTOL]] [[unmanned aircraft system|drones]]<ref>{{Cite web |last=Hobbs |first=Kerianne |date=December 2022 |title=Year of Autonomy in Alaskan Glaciers, Flight, Earth Orbit, Cislunar Space and Mars |url=https://digitaleditions.walsworth.com/publication/?m=7270&i=769555&p=48 |publisher=Aerospace America Year in Review |page=48 |quote=The flight test team was able to demonstrate … a vertical takeoff and landing vehicle with both electric and conventional fuel propulsion systems onboard. The [[unmanned aircraft system|[uncrewed aerial system]]] was able to plan and execute these missions autonomously using onboard hardware. It was the first time the Julia programming language was flown on the embedded hardware - algorithms were precompiled ahead of time. <!-- Too much detail to also include this in footnote?: The algorithms used to perform the various missions involved feedback control, mixed-integer linear programming and optimal control. --> |access-date=26 January 2023 |archive-date=19 June 2024 |archive-url=https://web.archive.org/web/20240619193142/https://digitaleditions.walsworth.com/publication/?m=7270&i=769555&p=48 |url-status=live }}</ref>
 
====Pharmaceuticals and drug development====
Julia is widely used for drug development in the pharmaceutical industry, having been adopted by [[Moderna]], [[Pfizer]], [[AstraZeneca]], [[Procter & Gamble]], and [[United Therapeutics]].<ref>{{Cite web |title=Case Study - JuliaHub |url=https://juliahub.com/case-studies/ |access-date=2023-02-10 |website=juliahub.com |archive-date=10 February 2023 |archive-url=https://web.archive.org/web/20230210211700/https://juliahub.com/case-studies/ |url-status=live }}</ref><ref>{{Cite web |title=Pumas-AI |url=https://pumas.ai/ |access-date=2023-02-10 |website=Pumas-AI |language=en |archive-date=10 February 2023 |archive-url=https://web.archive.org/web/20230210211700/https://pumas.ai/ |url-status=live }}</ref>
 
===Economics, finance, and political science===
* The [[Federal Reserve Bank of New York]] have used Julia for macroeconomic modeling since 2015, including estimates of [[COVID-19]] shocks in 2021<ref>{{Cite web |title=Release v1.3.0 · FRBNY-DSGE/DSGE.jl |url=https://github.com/FRBNY-DSGE/DSGE.jl/releases/tag/v1.3.0 |access-date=2022-01-03 |website=[[GitHub]] |language=en |quote=New subspecs of Model1002 for estimating the DSGE with COVID-19 shocks |archive-date=3 January 2022 |archive-url=https://web.archive.org/web/20220103170726/https://github.com/FRBNY-DSGE/DSGE.jl/releases/tag/v1.3.0 |url-status=live }}</ref>
* Also the [[Bank of Canada]], [[central bank]], for macroeconomic modeling<ref>{{Cite web |date=2023-05-02 |title=Finance and Economics Use Cases |url=https://discourse.julialang.org/t/finance-and-economics-use-cases/9452/104 |access-date=2023-05-04 |website=Julia Programming Language |language=en}}</ref>
* [[BlackRock]], the world's largest asset manager, for [[financial time-series analysis]]<ref name=":0">{{Cite web |last=D'Cunha |first=Suparna Dutt |date=2017-09-20 |title=How A New Programming Language Created By Four Scientists Now Used By The World's Biggest Companies |url=https://www.forbes.com/sites/suparnadutt/2017/09/20/this-startup-created-a-new-programming-language-now-used-by-the-worlds-biggest-companies/ |url-status=live |archive-url=https://web.archive.org/web/20221001082708/https://www.forbes.com/sites/suparnadutt/2017/09/20/this-startup-created-a-new-programming-language-now-used-by-the-worlds-biggest-companies/?sh=2c98522a7de2 |archive-date=2022-10-01 |access-date=2022-10-01 |website=Forbes |language=en}}</ref>
* [[Aviva]], the [[United Kingdom|UK]]'s largest general insurer, for actuarial calculations<ref name=":0" />
* [[Mitre Corporation]], for verification of published election results<ref>{{Cite web |title=Julia for Election Security |date=23 September 2022 |url=https://forem.julialang.org/ramsdell/julia-for-election-security-4gh |access-date=2022-09-27 |publisher=Julia Forem |language=en |archive-date=4 September 2024 |archive-url=https://web.archive.org/web/20240904035047/https://forem.julialang.org/ramsdell/julia-for-election-security-4gh |url-status=live }}</ref>
* Nobel laureate [[Thomas J. Sargent]], for [[Macroeconometrics|macroeconometric modeling]]<ref>{{Cite web |title=Nobel Laureate Thomas J. Sargent - JuliaHub |url=https://juliahub.com/case-studies/thomas-sargent/ |access-date=2023-02-10 |website=juliahub.com |archive-date=10 February 2023 |archive-url=https://web.archive.org/web/20230210211659/https://juliahub.com/case-studies/thomas-sargent/ |url-status=live }}</ref>
 
==See also==
{{Portal|Computer programming|Free and open-source software}}
* [[MATLAB]]
* [[Comparison of numerical-analysis software]]
* [[NumPy]], [[SciPy]]
* [[Comparison of statistical packages]]
* [[R (programming language)]]
* [[Differentiable programming]]
* [[Mathematica]]
* [[JuMP]] {{ndash}} an algebraic modeling language for mathematical optimization embedded in Julia
* [[Fortress (programming language)]]
* [[DylanPython (programming language)|Python]]
* [[Nim (programming language)|Nim]]
* [[Fortran]]
* [[CRing (programming language)|Ring]]
* [[Mojo (programming language)|Mojo]]
 
==References==
{{Reflist|25em}}
 
==Further reading==
* {{cite book|last=Nagar|first=Sandeep|year=2017|title=Beginning Julia Programming: For Engineers and Scientists|publisher=Springer |isbn=978-1-4842-3171-5 |url=https://books.google.com/books?id=KmRADwAAQBAJ&pg=PR1 }}
* [http://docs.julialang.org/en/latest/manual/ The Official Julia Manual]
* {{cite journal|last1=Bezanson|first1=J|last2=Edelman|first2=A|last3=Karpinski|first3=S|last4=Shah|first4=V. B|year=2017|title=Julia: A fresh approach to numerical computing|journal=SIAM Review |volume=59 |issue=1 |pages=65–98 |doi=10.1137/141000671 |arxiv=1411.1607 |citeseerx=10.1.1.760.8894|s2cid=13026838}}
* {{cite book|last=Joshi|first=Anshul|year=2016|title=Julia for Data Science － Explore the world of data science from scratch with Julia by your side|publisher=Packt |isbn=978-1-78355-386-0 |url=https://books.google.com/books?id=Bn9cDgAAQBAJ&pg=PP2}}
* Tobin A Driscoll and Richard J. Braun (Aug. 2022). ''Fundamentals of Numerical Computation: Julia Edition''. SIAM. {{ISBN|978-1-611977-00-4}}.
* C. T. Kelley (2022). ''Solving Nonlinear Equations with Iterative Methods: Solvers and Examples in Julia'', SIAM. {{ISBN|978-1-611977-26-4}}.
* {{cite book|last=Kalicharan|first=Noel|year=2021|title=Julia - Bit by Bit|series=Undergraduate Topics in Computer Science |publisher=Springer |doi=10.1007/978-3-030-73936-2 |isbn=978-3-030-73936-2 |s2cid=235917112 |url=https://link.springer.com/book/10.1007/978-3-030-73936-2 }}
* Clemens Heitzinger (2022): ''Algorithms with Julia'', Springer, ISBN 978-3-031-16559-7.
* Kenneth Lange (Jun. 2025): ''Algorithms from THE BOOK'' (2nd Ed.), SIAM, ISBN 978-1-61197-838-4.
 
==External links==
{{Wikibooks|Introducing Julia}}
* {{Official website|https://julialang.org}}
* {{GitHub|JuliaLang/Julia}}
 
{{Programming languages}}
{{FOSS}}
{{Numerical analysis software}}
{{Mathematical optimization software}}
{{Statistical software}}
{{Differentiable computing}}
{{Authority control}}
 
[[Category:2012 software]]
[[Category:Array programming languages]]
[[Category:Articles with example Julia code]]
[[Category:Notebook interface]]
[[Category:Cross-platform software]]
[[Category:Data mining and machine learning software]]
[[Category:Data-centric programming languages]]
[[Category:Dynamically typed programming languages]]
[[Category:Free and open source compilers]]
[[Category:Free and open source interpreters]]<!-- note there's also a Julia interpreter (not on by default); besides FemtoLisp.-->
[[Category:Free computer libraries]]
[[Category:Free data analysis software]]
[[Category:Free data and information visualization software]]
[[Category:Free software programmed in C]]
[[Category:Free software programmed in Julia]] <!-- Julia is written, mostly, in Julia. -->
[[Category:Free software projects]]
[[Category:Free statistical software]]
[[Category:Functional languages]]
[[Category:High-level programming languages]]
[[Category:LinuxHomoiconic numericalprogramming analysis softwarelanguages]]
[[Category:Lisp programming language family]]
[[Category:Multi-paradigm programming languages]]<!-- ok? Mostly only using the main paradigm multiple-dispatch, but Julia enables using more, in Julia everything is an object, non-traditional OO but traditional possible; e.g. class-based OO available with a package, emulating Python's OO style. -->
[[Category:Numerical analysis software for Linux]]
[[Category:Numerical analysis software for macOS]]
[[Category:Numerical analysis software for Windows]]
[[Category:Numerical libraries]] <!-- For Julia's standard library: seems ok, as e.g. all of C's libm (or what Julia used) has been rewritten in Julia. It's planned to remove libm, it only has a problem on 32-bit Windows blocking it.-->
[[Category:Numerical linear algebra]]
[[Category:Numerical programming languages]]
[[Category:Object-oriented programming languages]]
[[Category:SystemsParallel programming languagescomputing]]
[[Category:Procedural programming languages]]
[[Category:Programming languages]]
[[Category:Programming languages created in 2012]]
<!-- [[Category:Scripting languages]] ? -->
[[Category:Software using the MIT license]]
[[Category:Statistical programming languages]]
[[Category:Text-oriented programming languages]]
[[Category:Programming languages supporting units of measure]]
Retrieved from "https://en.wikipedia.org/wiki/Julia_(programming_language)"