Content deleted Content added
m Unicode 16.0 on DEV/next version. 1.5.1 on current. |
Rescuing orphaned refs ("infoworld" from rev 1301081049) |
||
| (47 intermediate revisions by 23 users not shown) | |||
Line 4:
| name = Julia
| logo = Julia Programming Language Logo.svg
| logo size =
| screenshot = <!-- filename is enough -->
| screenshot caption =
Line 43 ⟶ 42:
}}</ref>
| latest_release_version = {{wikidata|property|edit|reference|Q28974961 |P548=Q2804309|P348}}
| latest_release_date = {{nowrap|{{start date and age|{{wikidata|qualifier| Q28974961
| 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 =
| 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 =
Line 53 ⟶ 52:
* [[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"/>
Line 66 ⟶ 65:
"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 1: 64- and 32-bit [[
| 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.
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
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"
| last = Krill
| first = Paul
Line 93 ⟶ 100:
| 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:
▲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 /> 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 by calling them, e.g. calling [[C (programming language)|C]] or [[Rust (programming)|Rust]] libraries, 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'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>
▲==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" /> 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>}}
Line 128 ⟶ 113:
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 1.1 was released in January 2019 with a new "exception stack" feature. Julia 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 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 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 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 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>
Line 143 ⟶ 128:
-->
Julia 1.11 was released on 7 October 2024 (and 1.11.
<!-- 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.
-->
===JuliaCon===
Line 191 ⟶ 176:
* 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
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.
Line 225 ⟶ 213:
==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">
Line 239 ⟶ 227:
</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 1.12.0-
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=
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===
Line 254 ⟶ 244:
==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
===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.
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 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:
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 been built <!--on the following ARMv8 devices:▼
* [https://www.nvidia.com/object/embedded-systems-dev-kits-modules.html nVidia Jetson TX1 & TX2];
Line 267 ⟶ 257:
* [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 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>
Line 278 ⟶ 269:
"[[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.
Line 287 ⟶ 279:
|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 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> Julia has also been built for 64-bit [[RISC-V]],<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> that has some supporting code in core Julia.
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 [[Hertz#Computers|MHz]] [[8-bit computing|8-bit]] ([[ATmega328P]]) [[AVR microcontrollers|AVR-microcontroller]] Arduino with 2 KB RAM (plus 32 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==
Line 300 ⟶ 294:
* [[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>
* 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>
Line 317 ⟶ 312:
==See also==
{{Portal|Computer programming|Free and open-source software}}
* [[Comparison of numerical-analysis software]]
* [[Comparison of statistical packages]]
Line 333 ⟶ 329:
* {{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).
* C. T. Kelley (2022).
* {{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):
* Kenneth Lange (Jun. 2025): ''Algorithms from THE BOOK'' (2nd Ed.), SIAM, ISBN 978-1-61197-838-4.
==External links==
Line 360 ⟶ 357:
[[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. -->
| |||