Mojo (programming language)

Last updated
Mojo
Paradigm
Family Python
Designed by Chris Lattner
Developer Modular Inc.
First appeared2023;1 year ago (2023)
Preview release
24.4 [1] / May 24, 2024;7 days ago (2024-05-24)
Typing discipline
OS Cross-platform
License Proprietary
Filename extensions .🔥 (the fire emoji/U+1F525 Unicode character), alternatively .mojo
Website www.modular.com/mojo
Influenced by
Python, Cython [ citation needed ], C, C++, Rust, Swift, Zig

Mojo is a programming language in the Python family that is currently under development. [2] [3] [4] It is available both in browsers via Jupyter notebooks, [4] [5] and locally on Linux and macOS. [6] [7] Mojo aims to combine the usability of higher level programming languages, specifically Python, with the performance of lower level programming languages like C++, Rust, and Zig. [8] . The Mojo compiler is currently closed source with an open source standard library, although Modular has stated their intent to eventually open source the Mojo programming language itself as it matures. [9]

Contents

Mojo builds upon the MLIR compiler framework instead of directly on the lower level LLVM compiler framework that many languages like Julia, Swift, clang and Rust do. [10] [11] MLIR is a newer compiler framework that allows Mojo to take advantage of higher level compiler passes not available in LLVM alone and allows Mojo to compile down and target more than just CPUs, including producing code that can run on GPUS, TPUS, ASICs and other accelerators. It can also often more effectively use certain types of CPU optimizations directly, like SIMD without direct intervention by the developer like in many other languages. [12] [13] . According to Jeremey Howard of fast.ai, Mojo can be seen as "syntax sugar for MLIR" and for that reason Mojo is well optimized for applications like AI. [14] .

Origin and Development History

The Mojo programming language was created by Modular Inc, which was founded by Chris Lattner, the original architect of the Swift programming language and LLVM, and Tim Davis, a former Google employee. [15]

According to public change logs, Mojo development goes back to 2022. [16] In May of 2023, the first publicly testable version was made available online via a hosted playground. [17] By September 2023 Mojo was available for local download for Linux [18] and by October 2023 it was also made available for download on Apple's macOS. [19]

In March of 2024, Modular open sourced the Mojo standard library and started accepting community contributions under the Apache 2.0 license. [20] [21]

Features

Programming examples

In Mojo, functions can be declared using both fn (for performant functions) or def (for Python compatibility). [25]

Basic arithmetic operations in Mojo with a def function:

defsub(x,y):"""A pythonic subtraction."""res=x-yreturnres

and with an fn function:

fnadd(x: Int,y: Int)-> Int:     """A rustacean addition."""letres: Int=x+yreturnres

The manner in which Mojo employs var and let for mutable and immutable variable declarations respectively mirrors the syntax found in Swift. In Swift, var is used for mutable variables, while let is designated for constants or immutable variables. [25]

Variable declaration and usage in Mojo:

fnmain():     letx=1lety: Inty=1varz=0z+=1

Usage

The Mojo SDK allows Mojo programmers to compile and execute Mojo source files locally from the command line and currently supports Ubuntu and macOS. [29] Additionally, there is a Mojo extension for Visual Studio Code which provides code completion and tooltips.

In January 2024, an inference model of LLaMA2 written in Mojo was released to the public. [30]

See also

Related Research Articles

<span class="mw-page-title-main">Python (programming language)</span> General-purpose programming language

Python is a high-level, general-purpose programming language. Its design philosophy emphasizes code readability with the use of significant indentation.

In programming languages, a closure, also lexical closure or function closure, is a technique for implementing lexically scoped name binding in a language with first-class functions. Operationally, a closure is a record storing a function together with an environment. The environment is a mapping associating each free variable of the function with the value or reference to which the name was bound when the closure was created. Unlike a plain function, a closure allows the function to access those captured variables through the closure's copies of their values or references, even when the function is invoked outside their scope.

Standard ML (SML) is a general-purpose, high-level, modular, functional programming language with compile-time type checking and type inference. It is popular for writing compilers, for programming language research, and for developing theorem provers.

In object-oriented (OO) and functional programming, an immutable object is an object whose state cannot be modified after it is created. This is in contrast to a mutable object, which can be modified after it is created. In some cases, an object is considered immutable even if some internally used attributes change, but the object's state appears unchanging from an external point of view. For example, an object that uses memoization to cache the results of expensive computations could still be considered an immutable object.

<span class="mw-page-title-main">D (programming language)</span> Multi-paradigm system programming language

D, also known as dlang, is a multi-paradigm system programming language created by Walter Bright at Digital Mars and released in 2001. Andrei Alexandrescu joined the design and development effort in 2007. Though it originated as a re-engineering of C++, D is now a very different language drawing inspiration from other high-level programming languages, notably Java, Python, Ruby, C#, and Eiffel.

In computer programming, a default argument is an argument to a function that a programmer is not required to specify. In most programming languages, functions may take one or more arguments. Usually, each argument must be specified in full. Later languages allow the programmer to specify default arguments that always have a value, even if one is not specified when calling the function.

<span class="mw-page-title-main">LLVM</span> Compiler backend for multiple programming languages

LLVM is a set of compiler and toolchain technologies that can be used to develop a frontend for any programming language and a backend for any instruction set architecture. LLVM is designed around a language-independent intermediate representation (IR) that serves as a portable, high-level assembly language that can be optimized with a variety of transformations over multiple passes. The name LLVM originally stood for Low Level Virtual Machine, though the project has expanded and the name is no longer officially an initialism.

In a programming language, an evaluation strategy is a set of rules for evaluating expressions. The term is often used to refer to the more specific notion of a parameter-passing strategy that defines the kind of value that is passed to the function for each parameter and whether to evaluate the parameters of a function call, and if so in what order. The notion of reduction strategy is distinct, although some authors conflate the two terms and the definition of each term is not widely agreed upon.

<span class="mw-page-title-main">Scala (programming language)</span> General-purpose programming language

Scala is a strong statically typed high-level general-purpose programming language that supports both object-oriented programming and functional programming. Designed to be concise, many of Scala's design decisions are intended to address criticisms of Java.

<span class="mw-page-title-main">Python syntax and semantics</span> Set of rules defining correctly structured programs

The syntax of the Python programming language is the set of rules that defines how a Python program will be written and interpreted. The Python language has many similarities to Perl, C, and Java. However, there are some definite differences between the languages. It supports multiple programming paradigms, including structured, object-oriented programming, and functional programming, and boasts a dynamic type system and automatic memory management.

Haxe is a high-level cross-platform programming language and compiler that can produce applications and source code for many different computing platforms from one code-base. It is free and open-source software, released under an MIT License. The compiler, written in OCaml, is released under the GNU General Public License (GPL) version 2.

In computer programming, an anonymous function is a function definition that is not bound to an identifier. Anonymous functions are often arguments being passed to higher-order functions or used for constructing the result of a higher-order function that needs to return a function. If the function is only used once, or a limited number of times, an anonymous function may be syntactically lighter than using a named function. Anonymous functions are ubiquitous in functional programming languages and other languages with first-class functions, where they fulfil the same role for the function type as literals do for other data types.

Christopher Arthur Lattner is an American computer scientist and creator of LLVM, the Clang compiler, the Swift programming language and the MLIR compiler infrastructure.

<span class="mw-page-title-main">Rust (programming language)</span> General-purpose programming language

Rust is a multi-paradigm, general-purpose programming language that emphasizes performance, type safety, and concurrency. It enforces memory safety—meaning that all references point to valid memory—without a garbage collector. To simultaneously enforce memory safety and prevent data races, its "borrow checker" tracks the object lifetime of all references in a program during compilation.

<span class="mw-page-title-main">MLIR (software)</span> C++ framework for compiler development

MLIR is a unifying software framework for compiler development. MLIR can make optimal use of a variety of computing platforms such as GPUs, DPUs, TPUs, FPGAs, AI ASICS, and quantum computing systems (QPUs).

<span class="mw-page-title-main">Julia (programming language)</span> Dynamic programming language

Julia is a high-level, general-purpose dynamic programming language, most commonly used for numerical analysis and computational science. Distinctive aspects of Julia's design include a type system with parametric polymorphism and the use of multiple dispatch as a core programming paradigm, efficient garbage collection, and a just-in-time (JIT) compiler.

Objective-C is a high-level general-purpose, object-oriented programming language that adds Smalltalk-style messaging to the C programming language. Originally developed by Brad Cox and Tom Love in the early 1980s, it was selected by NeXT for its NeXTSTEP operating system. Due to Apple macOS’s direct lineage from NeXTSTEP, Objective-C was the standard programming language used, supported, and promoted by Apple for developing macOS and iOS applications until the introduction of the Swift programming language in 2014.

<span class="mw-page-title-main">GraalVM</span> Virtual machine software

GraalVM is a Java Development Kit (JDK) written in Java. The open-source distribution of GraalVM is based on OpenJDK, and the enterprise distribution is based on Oracle JDK. As well as just-in-time (JIT) compilation, GraalVM can compile a Java application ahead of time. This allows for faster initialization, greater runtime performance, and decreased resource consumption, but the resulting executable can only run on the platform it was compiled for.

Swift is a high-level general-purpose, multi-paradigm, compiled programming language created by Chris Lattner in 2010 for Apple Inc. and maintained by the open-source community. Swift compiles to machine code, as it is an LLVM-based compiler. Swift was first released in June 2014, and the Swift toolchain has shipped in Xcode since version 6, released in 2014.

<span class="mw-page-title-main">V (programming language)</span> General-purpose programming language

V, also known as vlang, is a statically typed, compiled programming language created by Alexander Medvednikov in early 2019. It was inspired by the language Go, and other influences including Oberon, Swift, and Rust. It is free and open-source software released under the MIT License, and currently in beta.

References

  1. ↑ "Mojo Changelog". Modular. Retrieved 2024-04-14.
  2. 1 2 "Mojo🔥 programming manual". docs.modular.com. Modular. 2023. Retrieved 2023-09-26. Mojo is a programming language that is as easy to use as Python but with the performance of C++ and Rust. Furthermore, Mojo provides the ability to leverage the entire Python library ecosystem.
  3. ↑ "Why Mojo🔥 - A language for next-generation compiler technology". docs.modular.com. Modular. 2023. Retrieved 2023-09-26. While many other projects now use MLIR, Mojo is the first major language designed expressly for MLIR, which makes Mojo uniquely powerful when writing systems-level code for AI workloads.
  4. 1 2 3 Krill, Paul (4 May 2023). "Mojo language marries Python and MLIR for AI development". InfoWorld.
  5. 1 2 Yegulalp, Serdar (7 June 2023). "A first look at the Mojo language". InfoWorld.
  6. ↑ Deutscher, Maria (7 September 2023). "Modular makes its AI-optimized Mojo programming language generally available". Silicon Angle. Retrieved 2023-09-11.
  7. ↑ "Mojo for Mac OS". Modular. Retrieved 2023-10-19.
  8. ↑ "Mojo 🔥: Programming language for all of AI". www.modular.com. Retrieved 2024-02-28.
  9. ↑ "Modular: The Next Big Step in Mojo🔥 Open Source". www.modular.com. Retrieved 2024-05-28.
  10. ↑ Krill, Paul (2023-05-04). "Mojo language marries Python and MLIR for AI development". InfoWorld. Retrieved 2024-05-28.
  11. ↑ "Should Julia use MLIR in the future?". Julia Programming Language. 2024-02-20. Retrieved 2024-05-28.
  12. ↑ "Why Mojo🔥 | Modular Docs". docs.modular.com. Retrieved 2024-05-28.
  13. ↑ https://llvm.org/devmtg/2023-10/slides/keynote/Mojo.pdf
  14. ↑ Howard, Jeremy (2023-05-04). "fast.ai - Mojo may be the biggest programming language advance in decades". fast.ai. Retrieved 2024-05-28.
  15. ↑ Claburn, Thomas (2023-05-05). "Modular finds its Mojo, a Python superset with C-level speed". The Register. Retrieved 2023-08-08.
  16. ↑ "Mojo🔥 changelog".
  17. ↑ "Modular: A unified, extensible platform to superpower your AI". www.modular.com. Retrieved 2024-04-14.
  18. ↑ "Modular: Mojo🔥 - It's finally here!". www.modular.com. Retrieved 2024-04-14.
  19. ↑ "Modular: Mojo🔥 is now available on Mac". www.modular.com. Retrieved 2024-04-14.
  20. ↑ "Modular open-sources its Mojo AI programming language's core components". SiliconANGLE. 2024-03-28. Retrieved 2024-05-28.
  21. ↑ "mojo/stdlib/README.md at nightly · modularml/mojo". GitHub. Retrieved 2024-05-28.
  22. ↑ Lattner, Chris; Pienaar, Jacques (2019). MLIR Primer: A Compiler Infrastructure for the End of Moore's Law (Technical report). Retrieved 2022-09-30.
  23. ↑ Lattner, Chris; Amini, Mehdi; Bondhugula, Uday; Cohen, Albert; Davis, Andy; Pienaar, Jacques; Riddle, River; Shpeisman, Tatiana; Vasilache, Nicolas; Zinenko, Oleksandr (2020-02-29). "MLIR: A Compiler Infrastructure for the End of Moore's Law". arXiv: 2002.11054 [cs.PL].
  24. ↑ "Modular Docs - Mojo🔥 programming manual". docs.modular.com. Retrieved 2023-10-19.
  25. 1 2 3 "Modular Docs - Mojo🔥 programming manual". docs.modular.com. Retrieved 2023-10-31.
  26. ↑ "Welcome to Mojo 🔥". GitHub . Modular. 2023-10-31. Retrieved 2023-10-31.
  27. ↑ "Ownership and borrowing | Modular Docs". Modular. Retrieved 2024-02-29.
  28. ↑ "Mojo🔥 programming manual". Modular. Archived from the original on 2023-06-11. Retrieved 2023-06-11. All values passed into a Python def function use reference semantics. This means the function can modify mutable objects passed into it and those changes are visible outside the function. However, the behavior is sometimes surprising for the uninitiated, because you can change the object that an argument points to and that change is not visible outside the function. All values passed into a Mojo def function use value semantics by default. Compared to Python, this is an important difference: A Mojo def function receives a copy of all arguments—it can modify arguments inside the function, but the changes are not visible outside the function.
  29. ↑ "Modular Docs - Mojo🔥 roadmap & sharp edges". docs.modular.com. Retrieved 2023-10-31.
  30. ↑ "llama2.mojo🔥 changelog". GitHub .
This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.