Here’s a language that’s supposed to be a superset of python but is much faster:
None
2023-01-01
<div><div><div><div><div><p></p><h2>Mojo ð¥ â a new programming language for all AIÂ developers.</h2><p></p></div><p>Mojo combines the usability of Python with the performance of C, unlocking unparalleled programmability of AI hardware and extensibility ofÂ AI models.</p></div><div><div><pre><code>def softmax(lst):
 norm = np.exp(lst - np.max(lst))
 return norm / norm.sum()</code></pre></div><div><pre><code>def softmax(lst):
 norm = np.exp(lst - np.max(lst))
 return norm / norm.sum()
struct NDArray:
 def max(self) -&gt; NDArray:
 return self.pmap(SIMD.max)
struct SIMD[type: DType, width: Int]:
 def max(self, rhs: Self) -&gt; Self:
 return (self &gt;= rhs).select(self, rhs)</code></pre></div></div></div><div><div><p>Usability &amp;Â Programmability</p></div><div><div><p></p><h2>Write everything inÂ one language</h2><p></p></div><div><div><p>Write Python or scale all the way down to the metal. Program the multitude of low-level AI hardware. No C++ or CUDA required.</p></div><p><a href="https://docs.modular.com/mojo/notebooks/HelloMojo.html">Take a tour of Mojo</a></p></div></div><div><div><div><div>
<pre><code>def sort(v: ArraySlice[Int]):
 for i in range(len(v)):
 for j in range(len(v) - i - 1):
 if v[j] &gt; v[j + 1]:
 swap(v[j], v[j + 1])</code></pre></div><div>
<pre><code>struct MyPair:
 var first: Int
 var second: F32
 
 def __init__(self, first: Int, second: F32):
 self.first = first
 self.second = second</code></pre></div><div>
<pre><code>def reorder_and_process(owned x: HugeArray):
 sort(x)	# Update in place
 
 give_away(x^)	# Transfer ownership
 
 print(x[0])	# Error: âxâ moved away!</code></pre></div><div>
<pre><code>def exp[dt: DType, elts: Int]
 (x: SIMD[dt, elts]) -&gt; SIMD[dt, elts]:
 x = clamp(x, -88.3762626647, 88.37626266)
 k = floor(x * INV_LN2 + 0.5)
 r = k * NEG_LN2 + x
 return ldexp(_exp_taylor(r), k)</code></pre></div><div>
<pre><code>def exp_buffer[dt: DType](data: ArraySlice[dt]):
 # Search for the best vector length
 alias vector_len = autotune(1, 4, 8, 16, 32)
 
 # Use it as the vectorization length
 vectorize[exp[dt, vector_len]](data)</code></pre></div></div><div><div><div><h3>Progressive Types</h3><p>Leverage types for better performance and error checking.</p></div><div><h3>Zero Cost Abstractions</h3><p>Take control of storage by inline-allocating values into structures.</p></div><div><h3>Ownership + borrow checker</h3><p>Take advantage of memory safety without the rough edges.</p></div><div><h3>Portable parametric algorithms</h3><p>Leverage compile-time meta-programming to write hardware-agnostic algorithms and reduce boilerplate.</p></div><div><h3>LANGUAGE INTEGRATED Auto-tuning</h3><p>Automatically find the best values for your parameters to take advantage of target hardware.</p></div></div><div><p>The full power of MLIR</p><p>Parallel heterogenous runtime</p><p>Fast compile times</p></div></div></div><div><div><div>
<pre><code>def sort(v: ArraySlice[Int]):
 for i in range(len(v)):
 for j in range(len(v) - i - 1):
 if v[j] &gt; v[j + 1]:
 swap(v[j], v[j + 1])</code></pre></div><div><p>Features include:</p><div><h3>Progressive Types</h3><p>Leverage types for better performance and error checking.</p></div></div></div><div><div>
<pre><code>struct MyPair:
 var first: Int
 var second: F32
 
 def __init__(self, first: Int, second: F32):
 self.first = first
 self.second = second</code></pre></div><div><p>Features include:</p><div><h3>Zero Cost Abstractions</h3><p>Take control of storage by inline-allocating values into structures.</p></div></div></div><div><div>
<pre><code>def reorder_and_process(owned x: HugeArray):
 sort(x)	# Update in place
 
 give_away(x^)	# Transfer ownership
 
 print(x[0])	# Error: âxâ moved away!</code></pre></div><div><p>Features include:</p><div><h3>Ownership + borrow checker</h3><p>Take advantage of memory safety without the rough edges.</p></div></div></div><div><div>
<pre><code>def exp[dt: DType, elts: Int]
 (x: SIMD[dt, elts]) -&gt; SIMD[dt, elts]:
 x = clamp(x, -88.3762626647, 88.37626266)
 k = floor(x * INV_LN2 + 0.5)
 r = k * NEG_LN2 + x
 return ldexp(_exp_taylor(r), k)</code></pre></div><div><p>Features include:</p><div><h3>Portable parametric algorithms</h3><p>Leverage compile-time meta-programming to write hardware-agnostic algorithms and reduce boilerplate.</p></div></div></div><div><div>
<pre><code>def exp_buffer[dt: DType](data: ArraySlice[dt]):
 # Search for the best vector length
 alias vector_len = autotune(1, 4, 8, 16, 32)
 
 # Use it as the vectorization length
 vectorize[exp[dt, vector_len]](data)</code></pre></div><div><p>Features include:</p><div><h3>LANGUAGE INTEGRATED Auto-tuning</h3><p>Automatically find the best values for your parameters to take advantage of target hardware.</p></div></div></div></div></div></div><div><div><div><p></p><h2>Unlock Python performance</h2><p></p></div><div><p>Utilize the full power of the hardware, including multiple cores, vector units, and exotic accelerator units, with the world's most advanced compiler and heterogenous runtime. Achieve performance on par with C++ and CUDA without the complexity.</p></div></div><div><div><h3>Parallelization</h3><p>Mojo leverages MLIR, which enables Mojo developers to take advantage of vectors, threads, and AI hardware units.</p></div><div><div><h3>PYTHON</h3><p>Single-threaded execution</p></div><div><h3>Mojo ð¥</h3><p>Parallel processing across multiple cores</p></div></div></div><div><p>Instance</p><p>AWS r7iz.metal-16xl</p><p>Intel Xeon</p></div></div><div><div><div><p></p><h2>Access the entire Python ecosystem</h2><p></p></div><div><div><p>Experience true interoperability with the Python ecosystem. Seamlessly intermix arbitrary libraries like Numpy and Matplotlib and your custom code with Mojo.</p></div><p><a href="https://docs.modular.com/mojo/programming-manual.html#python-integration">Read the programming manual</a></p></div></div><div><div><pre><code>def make_plot(m: Matrix):
 plt = Python.import_module("matplotlib.pyplot")
 fig = plt.figure(1, [10, 10 * yn // xn], 64)
 ax = fig.add_axes([0.0, 0.0, 1.0, 1.0], False, 1)
 plt.imshow(image)
 plt.show()
make_plot(compute_mandelbrot())</code></pre></div><p></p></div></div><div><div><div><p></p><h2>Upgrade your models and the Modular stack</h2><p></p></div><div><p>Easily extend your models with pre and post-processing operations, or replace operations with custom ones. Take advantage of kernel fusion, graph rewrites, shape functions, and more.</p></div></div><div><div><p>Model extensibility</p><p>Mojo can upgrade the existing operations in your model.</p></div><div><p>Input layer</p><p>Hidden layers</p><p>Output layer</p></div></div></div><div><div><p></p><h2>Try Mojo ð¥ out right now inÂ our Playground</h2><p></p><div><div><p>Mojo is still a work in progress, but it's available to try today in our JupyterHub-based Playground. Run through tutorials and write your own Mojo code.</p></div><p><a href="/get-started">Sign up for access</a></p></div></div><div><div><p></p></div><div><div><h3>01.</h3><p>EASYÂ TOÂ GETÂ STARTED</p><p>We have plenty of easy-to-use Jupyter notebooks to help you get started learning Mojo ð¥.</p></div><div><h3>02.</h3><p>Unleash your mojo</p><p><a href="https://docs.modular.com/mojo">Our docs</a> will help you quickly discover why Mojo is such a powerful extension to Python, and the future of AI programming.</p></div></div></div></div></div></div>||||I|||| Engine
 Overview
 PERFORMANCE DASH
 dOCS
 Mojoð¥
 Overview
 Docs
 Hardware
 Blog
 Careers
 Company
 About
 Vision
 Team
 Newsletter
 Culture
 contact
 Sign inGet Started
 Menu

 Mojo ð¥ â a new programming language for all AIÂ developers .

 Mojo combines the usability of Python with the performance of C, unlocking unparalleled programmability of AI hardware and extensibility ofÂ AI models.

 Get started with MojoRead the docs
 SOFTMAX. PY
 Mojo ð¥
 python
 def softmax(lst):
 norm = np.exp(lst - np.max(lst))
 return norm / norm.sum()
 def softmax(lst):
 norm = np.exp(lst - np.max(lst))
 return norm / norm.sum()
 
 struct NDArray:
 def max(self) -> NDArray:
 return self.pmap(SIMD.max)
 
 struct SIMD[type: DType, width: Int]:
 def max(self, rhs: Self) -> Self:
 return (self >= rhs).select(self, rhs)
 01
 Usability &Â Programmability

 Write everything inÂ one language

 Write Python or scale all the way down to the metal. Program the multitude of low-level AI hardware. No C++ or CUDA required.

 Take a tour of Mojo
 def sort(v: ArraySlice[Int]):
 for i in range(len(v)):
 for j in range(len(v) - i - 1):
 if v[j] > v[j + 1]:
 swap(v[j], v[j + 1])
 struct MyPair:
 var first: Int
 var second: F32
 
 def __init__(self, first: Int, second: F32):
 self.first = first
 self.second = second
 def reorder_and_process(owned x: HugeArray):
 sort(x)	# Update in place
 
 give_away(x^)	# Transfer ownership
 
 print(x[0])	# Error: âxâ moved away!
 def exp[dt: DType, elts: Int]
 (x: SIMD[dt, elts]) -> SIMD[dt, elts]:
 x = clamp(x, -88.3762626647, 88.37626266)
 k = floor(x * INV_LN2 + 0.5)
 r = k * NEG_LN2 + x
 return ldexp(_exp_taylor(r), k)
 def exp_buffer[dt: DType](data: ArraySlice[dt]):
 
 # Search for the best vector length
 alias vector_len = autotune(1, 4, 8, 16, 32)
 
 # Use it as the vectorization length
 vectorize[exp[dt, vector_len]](data)
 Features include:

 Progressive Types

 Leverage types for better performance and error checking.

 Zero Cost Abstractions

 Take control of storage by inline-allocating values into structures.

 Ownership + borrow checker

 Take advantage of memory safety without the rough edges.

 Portable parametric algorithms

 Leverage compile-time meta-programming to write hardware-agnostic algorithms and reduce boilerplate.

 LANGUAGE INTEGRATED Auto-tuning

 Automatically find the best values for your parameters to take advantage of target hardware.

 As well as:

 The full power of MLIR

 Parallel heterogenous runtime

 Fast compile times

 def sort(v: ArraySlice[Int]):
 for i in range(len(v)):
 for j in range(len(v) - i - 1):
 if v[j] > v[j + 1]:
 swap(v[j], v[j + 1])
 Features include:

 Progressive Types

 Leverage types for better performance and error checking.

 struct MyPair:
 var first: Int
 var second: F32
 
 def __init__(self, first: Int, second: F32):
 self.first = first
 self.second = second
 Features include:

 Zero Cost Abstractions

 Take control of storage by inline-allocating values into structures.

 def reorder_and_process(owned x: HugeArray):
 sort(x)	# Update in place
 
 give_away(x^)	# Transfer ownership
 
 print(x[0])	# Error: âxâ moved away!
 Features include:

 Ownership + borrow checker

 Take advantage of memory safety without the rough edges.

 def exp[dt: DType, elts: Int]
 (x: SIMD[dt, elts]) -> SIMD[dt, elts]:
 x = clamp(x, -88.3762626647, 88.37626266)
 k = floor(x * INV_LN2 + 0.5)
 r = k * NEG_LN2 + x
 return ldexp(_exp_taylor(r), k)
 Features include:

 Portable parametric algorithms

 Leverage compile-time meta-programming to write hardware-agnostic algorithms and reduce boilerplate.

 def exp_buffer[dt: DType](data: ArraySlice[dt]):
 
 # Search for the best vector length
 alias vector_len = autotune(1, 4, 8, 16, 32)
 
 # Use it as the vectorization length
 vectorize[exp[dt, vector_len]](data)
 Features include:

 LANGUAGE INTEGRATED Auto-tuning

 Automatically find the best values for your parameters to take advantage of target hardware.

 02
 Performance

 Unlock Python performance

 Utilize the full power of the hardware, including multiple cores, vector units, and exotic accelerator units, with the world's most advanced compiler and heterogenous runtime. Achieve performance on par with C++ and CUDA without the complexity.

 Play with Mojo

 Parallelization

 Mojo leverages MLIR, which enables Mojo developers to take advantage of vectors, threads, and AI hardware units.

 PYTHON

 Single-threaded execution

 Mojo ð¥

 Parallel processing across multiple cores

 Languages
 Time (S) *
 Speedup vs Python
 Python 3.10.9
 1027 s
 1x
 Pypy
 46.1 s
 22x
 Scalar C++
 0.20 s
 5000x
 Mojo ð¥
 0.03 s
 35000x
 * Algorithm
 Mandelbrot
 Instance
 AWS r7iz.metal-16xl
 Intel Xeon
 03
 Interoperability

 Access the entire Python ecosystem

 Experience true interoperability with the Python ecosystem. Seamlessly intermix arbitrary libraries like Numpy and Matplotlib and your custom code with Mojo.

 Read the programming manual
 MAKE_PLOT.ð¥
 def make_plot(m: Matrix):
 plt = Python.import_module("matplotlib.pyplot")
 fig = plt.figure(1, [10, 10 * yn // xn], 64)
 ax = fig.add_axes([0.0, 0.0, 1.0, 1.0], False, 1)
 plt.imshow(image)
 plt.show()
 
 make_plot(compute_mandelbrot())
 Mojo ð¥
 04
 Extensibility

 Upgrade your models and the Modular stack

 Easily extend your models with pre and post-processing operations, or replace operations with custom ones. Take advantage of kernel fusion, graph rewrites, shape functions, and more.

 Model extensibility

 Mojo can upgrade the existing operations in your model.

 Input layer
 Hidden layers
 Output layer
 05
 GETÂ STARTEDÂ NOW

 Try Mojo ð¥ out right now inÂ our Playground

 Mojo is still a work in progress, but it's available to try today in our JupyterHub-based Playground. Run through tutorials and write your own Mojo code.

 Sign up for access
 Mojo ð¥

 01.

 EASYÂ TOÂ GETÂ STARTED

 We have plenty of easy-to-use Jupyter notebooks to help you get started learning Mojo ð¥.

 02.

 Unleash your mojo

 Our docs will help you quickly discover why Mojo is such a powerful extension to Python, and the future of AI programming.

 03.

 JOINÂ theÂ mojo COMMUNITY

 Come and chat with us on our Discord, and help shape the future of the language as we continue to develop it.

 Ready to play with Mojo?

 Reach out to gain access to the Mojo Playground.

 Request access
 API Reference, Tutorials, & More

 Read the Mojo docs

 Engine
 Mojo ð¥
 Hardware
 Performance
 Get Started
 Blog
 Careers

 Copyright Â©

 2023,

 Modular Inc

 Terms
 ,
 Privacy
 &
 Acceptable Use
Mojo ð¥: Programming language for all of AI
https://www.modular.com/mojo
Jeff Bezanson, Stefan Karpinski, Viral Shah, Alan Edelman, et al.
2024-05-03T00:00:00Z
<div><div>
        <div>
          <h3>General Computing</h3>
          <p></p><div>
            <h4>Build, Deploy or Embed Your Code</h4>
            <p>
              Julia makes it possible to build complete applications. Write web UIs with <a href="https://github.com/plotly/Dash.jl">Dash.jl</a> and <a href="https://github.com/GenieFramework/Genie.jl">Genie.jl</a> or native UIs with <a href="https://github.com/JuliaGraphics/Gtk.jl">GTK.jl</a>. Pull data from <a href="https://juliadatabases.org">a variety of databases</a>. Build shared libraries and executables with <a href="https://github.com/JuliaLang/PackageCompiler.jl">PackageCompiler</a>. Deploy on a webserver with <a href="https://github.com/JuliaWeb/HTTP.jl">HTTP.jl</a> or embedded devices. Powerful shell integration make it easy to <a href="https://docs.julialang.org/en/v1/manual/running-external-programs/">managing other processes</a>.
            </p>
            <p>
              Julia has foreign function interfaces for
                <a href="https://docs.julialang.org/en/v1/manual/calling-c-and-fortran-code/">C, Fortran</a>,
                <a href="https://github.com/JuliaInterop/CxxWrap.jl">C++</a>,
                <a href="https://github.com/JuliaPy/PythonCall.jl">Python</a>,
                <a href="https://github.com/JuliaInterop/RCall.jl">R</a>,
                <a href="https://github.com/JuliaInterop/JavaCall.jl">Java</a>,
                <a href="https://github.com/JuliaInterop/MathLink.jl">Mathematica</a>,
                <a href="https://github.com/JuliaInterop/MATLAB.jl">Matlab</a>,
                and many other languages. Julia can also be embedded in other programs through its <a href="https://docs.julialang.org/en/v1/manual/embedding/">embedding API</a>. Julia's <a href="https://github.com/JuliaLang/PackageCompiler.jl">PackageCompiler</a> makes it possible to build binaries from Julia programs that can be integrated into larger projects. Python programs can call Julia using <a href="https://github.com/JuliaPy/PythonCall.jl">juliacall</a>. R programs can do the same with <a href="https://cran.r-project.org/web/packages/JuliaCall/index.html">R's JuliaCall</a>, which is demonstrated by <a href="https://rpubs.com/dmbates/377897">calling MixedModels.jl from R</a>. Mathematica supports <a href="https://reference.wolfram.com/language/ref/externalevaluationsystem/Julia.html">calling Julia through its External Evaluation System</a>.
            </p>
          </div>
        </div>

      
        <div>
          <h3>Parallel Computing</h3>
          <div>
              <p></p>
            </div>
        </div>

      
        <div>
          <h3>Machine Learning</h3>
          <div>
              <p></p>
            </div>
        </div>

      
        <div>
          <h3>Scientific Computing</h3>
          <div>
              <p></p><div>
                <h4>
                  Rich Ecosystem for Scientific Computing
                </h4>
                <p>Julia is designed from the ground up to be very good at numerical and scientific computing.
                This can be seen in the abundance of scientific tooling written in Julia, such as the state-of-the-art differential equations ecosystem <a href="https://github.com/SciML/DifferentialEquations.jl">(DifferentialEquations.jl)</a>, optimization tools (<a href="https://github.com/jump-dev/JuMP.jl">JuMP.jl</a> and <a href="https://github.com/JuliaNLSolvers/Optim.jl">Optim.jl</a>), iterative linear solvers <a href="https://github.com/JuliaMath/IterativeSolvers.jl">(IterativeSolvers.jl)</a>, Fast Fourier transforms <a href="https://github.com/JuliaMath/AbstractFFTs.jl">(AbstractFFTs.jl)</a>, and much more. General purpose simulation frameworks are available for <a href="https://sciml.ai">Scientific Machine Learning</a>, <a href="https://github.com/QuantumBFS/Yao.jl">Quantum computing</a> and much more.</p>
                <p>Julia also offers a number of domain-specific ecosystems, such as in biology <a href="https://github.com/BioJulia"> (BioJulia)</a>, operations research <a href="https://jump.dev"> (JuMP Dev)</a>, image processing <a href="https://juliaimages.github.io/latest/">(JuliaImages)</a>, quantum physics <a href="https://github.com/QuantumBFS">(QuantumBFS)</a>, nonlinear dynamics <a href="https://github.com/JuliaDynamics"> (JuliaDynamics)</a>, quantitative economics <a href="https://github.com/QuantEcon">(QuantEcon)</a>, astronomy <a href="https://juliaastro.github.io"> (JuliaAstro)</a> and ecology <a href="https://github.com/EcoJulia">(EcoJulia)</a>. With a set of highly enthusiastic developers and maintainers, the scientific ecosystem in Julia continues to grow rapidly. </p>
              </div>
            </div>
        </div>

        
        <div>
          <h3>Data Science</h3>
          <div>
              <p></p><div>
                <h4>Interact with your Data</h4>
                <p>The Julia data ecosystem provides <a href="https://github.com/JuliaData/DataFrames.jl">DataFrames.jl</a> to work with datasets, and perform common data manipulations. <a href="https://github.com/JuliaData/CSV.jl">CSV.jl</a> is a fast multi-threaded package to read CSV files and integration with the Arrow ecosystem is in the works with <a href="https://github.com/JuliaData/Arrow.jl">Arrow.jl</a>. Online computations on streaming data can be performed with <a href="https://github.com/joshday/OnlineStats.jl">OnlineStats.jl</a>.
                The <a href="https://www.queryverse.org/">Queryverse</a> provides query, file IO and visualization functionality. In addition to working with tabular data, the <a href="https://juliagraphs.org/">JuliaGraphs</a> packages make it easy to work with combinatorial data.</p>
                <p>Julia can work with almost all databases using <a href="https://github.com/JuliaDatabases/JDBC.jl">JDBC.jl</a> and <a href="https://github.com/JuliaDatabases/ODBC.jl">ODBC.jl</a> drivers. In addition, it also integrates with the Spark ecosystem through <a href="https://github.com/dfdx/Spark.jl">Spark.jl</a>.</p>
              </div>
            </div>
        </div>

        
        <div>
          <h3>Visualization</h3>
          <div>
                <p></p><h4>Data Visualization and Plotting</h4>
                <p>Data visualization has a complicated history. Plotting software makes trade-offs between features and simplicity, speed and beauty, and a static and dynamic interface. Some packages make a display and never change it, while others make updates in real-time.</p>
                <p><a href="https://github.com/JuliaPlots/Plots.jl">Plots.jl</a> is a visualization interface and toolset. It provides a common API across various <a href="https://docs.juliaplots.org/latest/backends/">backends</a>, like <a href="https://github.com/jheinen/GR.jl">GR.jl</a>, <a href="https://github.com/JuliaPy/PyPlot.jl">PyPlot.jl</a>, and <a href="https://github.com/JuliaPlots/PlotlyJS.jl">PlotlyJS.jl</a>. <a href="https://github.com/MakieOrg/Makie.jl">Makie.jl</a> is a sophisticated package for complex graphics and animations. Users who are used to "grammar of graphics" plotting APIs should take a look at <a href="https://github.com/GiovineItalia/Gadfly.jl">Gadfly.jl</a>. <a href="https://github.com/queryverse/VegaLite.jl">VegaLite.jl</a> provides the <a href="https://vega.github.io/vega-lite/">Vega-Lite</a> grammar of interactive graphics interface as a Julia package. For those who do not wish to leave the comfort of the terminal, there is also <a href="https://github.com/Evizero/UnicodePlots.jl">UnicodePlots.jl</a>.</p>
              </div>


          
        </div>
      </div></div>||||I||||    Did you miss JuliaCon 2024? Watch the 11th annual JuliaCon talks on YouTube!

    ×
      * Download
      * Documentation
      * Learn
      * Blog
      * Community
      * Contribute
      * JSoC
    Star Sponsor

    The Julia Programming Language

    Download Documentation Star

      Julia in a Nutshell


      Fast

      Julia was designed for high performance. Julia programs automatically compile to efficient native code via LLVM, and support multiple platforms.

      Dynamic

      Julia is dynamically typed, feels like a scripting language, and has good support for interactive use, but can also optionally be separately compiled.

      Reproducible

      Reproducible environments make it possible to recreate the same Julia environment every time, across platforms, with pre-built binaries.

      Composable

      Julia uses multiple dispatch as a paradigm, making it easy to express many object-oriented and functional programming patterns. The talk on the Unreasonable Effectiveness of Multiple Dispatch explains why it works so well.

      General

      Julia provides asynchronous I/O, metaprogramming, debugging, logging, profiling, a package manager, and more. One can build entire Applications and Microservices in Julia.

      Open source

      Julia is an open source project with over 1,000 contributors. It is made available under the MIT license. The source code is available on GitHub.


      See Julia Code Examples Try Julia In Your Browser



        Ecosystem


        * Visualization
        * General Purpose
        * Data Science
        * Machine Learning
        * Scientific Domains
        * Parallel Computing

        General Computing

          Build, Deploy or Embed Your Code

          Julia makes it possible to build complete applications. Write web UIs with Dash.jl and Genie.jl or native UIs with GTK.jl. Pull data from a variety of databases. Build shared libraries and executables with PackageCompiler. Deploy on a webserver with HTTP.jl or embedded devices. Powerful shell integration make it easy to managing other processes.

          Julia has foreign function interfaces for C, Fortran, C++, Python, R, Java, Mathematica, Matlab, and many other languages. Julia can also be embedded in other programs through its embedding API. Julia's PackageCompiler makes it possible to build binaries from Julia programs that can be integrated into larger projects. Python programs can call Julia using juliacall. R programs can do the same with R's JuliaCall, which is demonstrated by calling MixedModels.jl from R. Mathematica supports calling Julia through its External Evaluation System.

        Parallel Computing

              Parallel and Heterogeneous Computing

              Julia is designed for parallelism, and provides built-in primitives for parallel computing at every level: instruction level parallelism, multi-threading, GPU computing, and distributed computing. The Celeste.jl project achieved 1.5 PetaFLOP/s on the Cori supercomputer at NERSC using 650,000 cores.

              The Julia compiler can also generate native code for GPUs. Packages such as DistributedArrays.jl and Dagger.jl provide higher levels of abstraction for parallelism. Distributed Linear Algebra is provided by packages like Elemental.jl and TSVD.jl. MPI style parallelism is also available through MPI.jl.

        Machine Learning

              Scalable Machine Learning

              The MLJ.jl package provides a unified interface to common machine learning algorithms, which include generalized linear models, decision trees, and clustering. Flux.jl and Lux.jl are powerful packages for Deep Learning. Packages such as Metalhead.jl, ObjectDetector.jl, and TextAnalysis.jl provide ready to use pre-trained models for common tasks. AlphaZero.jl provides a high performance implementation of the reinforcement learning algorithms from AlphaZero. Turing.jl is a best in class package for probabilistic programming.

        Scientific Computing

              Rich Ecosystem for Scientific Computing

              Julia is designed from the ground up to be very good at numerical and scientific computing. This can be seen in the abundance of scientific tooling written in Julia, such as the state-of-the-art differential equations ecosystem (DifferentialEquations.jl), optimization tools (JuMP.jl and Optim.jl), iterative linear solvers (IterativeSolvers.jl), Fast Fourier transforms (AbstractFFTs.jl), and much more. General purpose simulation frameworks are available for Scientific Machine Learning, Quantum computing and much more.

              Julia also offers a number of domain-specific ecosystems, such as in biology (BioJulia), operations research (JuMP Dev), image processing (JuliaImages), quantum physics (QuantumBFS), nonlinear dynamics (JuliaDynamics), quantitative economics (QuantEcon), astronomy (JuliaAstro) and ecology (EcoJulia). With a set of highly enthusiastic developers and maintainers, the scientific ecosystem in Julia continues to grow rapidly.

        Data Science

              Interact with your Data

              The Julia data ecosystem provides DataFrames.jl to work with datasets, and perform common data manipulations. CSV.jl is a fast multi-threaded package to read CSV files and integration with the Arrow ecosystem is in the works with Arrow.jl. Online computations on streaming data can be performed with OnlineStats.jl. The Queryverse provides query, file IO and visualization functionality. In addition to working with tabular data, the JuliaGraphs packages make it easy to work with combinatorial data.

              Julia can work with almost all databases using JDBC.jl and ODBC.jl drivers. In addition, it also integrates with the Spark ecosystem through Spark.jl.

        Visualization

              Data Visualization and Plotting

              Data visualization has a complicated history. Plotting software makes trade-offs between features and simplicity, speed and beauty, and a static and dynamic interface. Some packages make a display and never change it, while others make updates in real-time.

              Plots.jl is a visualization interface and toolset. It provides a common API across various backends, like GR.jl, PyPlot.jl, and PlotlyJS.jl. Makie.jl is a sophisticated package for complex graphics and animations. Users who are used to "grammar of graphics" plotting APIs should take a look at Gadfly.jl. VegaLite.jl provides the Vega-Lite grammar of interactive graphics interface as a Julia package. For those who do not wish to leave the comfort of the terminal, there is also UnicodePlots.jl.

                Lorenz Attractor in Julia

                ×
                
                function fill_twos!(a)
                  for i=1:length(a)
                    a[i] = 2
                  end
                end
                
                function fast_strange_twos(n)
                  a = Array(randbool() ? Int64 : Float64, n)
                  fill_twos!(a)
                  return a
                end
                
                Close





      JuliaCon 2023

      Julia Channel on YouTube JuliaCon 2023 videos




        Packages


    Julia has been downloaded over 45 million times and the Julia community has registered over 10,000 Julia packages for community use. These include various mathematical libraries, data manipulation tools, and packages for general purpose computing. In addition to these, you can easily use libraries from Python, R, C/Fortran, C++, and Java. If you do not find what you are looking for, ask on Discourse, or even better, contribute one!



        JuliaHub: Package Search JuliaPackages: Trending Feed of new Julia packages




      Recent Blog Posts


      2024 GSoC and JSoC Fellows Announced

      2024-05-03

      nothing

      Julia 1.10 Highlights

      2023-12-27

      nothing

      PSA: Thread-local state is no longer recommended

      2023-07-06

      nothing


      Visit Blog View Community Posts




        Talk to us


        Discourse

        Discourse

        GitHub

        Source code

        Zulip

        Zulip

        Slack

        Slack

        Twitter

        #JuliaLang

        Videos

        YouTube

        LinkedIn

        LinkedIn

        Twitch

        Twitch





      Editors and IDEs


      VS Code

      VS Code Extension

      Jupyter

      Jupyter kernel

      Pluto.jl

      Simple reactive notebooks

      Vim

      Vim plugin

      Emacs

      Emacs plugin



      Essential Tools


      Debugger

      Debugger.jl

      Profiler

      Profile (Stdlib)

      Revise

      Revise.jl

      GPUs

      JuliaGPU


      * About
      * Get Help
      * Governance
      * Publications
      * Sponsors
      * Downloads
      * All Releases
      * Source Code
      * Current Stable Release
      * Longterm Support Release
      * Documentation
      * JuliaAcademy
      * YouTube
      * Getting Started
      * FAQ
      * Books
      * Community
      * Code of Conduct
      * Stewards
      * Diversity
      * Julia Gender Inclusive
      * JuliaCon
      * User/Developer Survey
      * Shop Merchandise
      * Contributing
      * Contributor's Guide
      * Issue Tracker
      * Report a Security Issue
      * Help Wanted Issues
      * Good First Issue
      * Dev Docs

      Last modified: 0001-01-01. This site is powered by Netlify, Franklin.jl, and the Julia Programming Language.

      We thank Fastly for their generous infrastructure support.

      ©2024 JuliaLang.org contributors. The content on this website is made available under the MIT license.

      Sponsor
The Julia Programming Language
https://julialang.org/