Mojo (programming language)

Last updated
Mojo
Paradigm
Family Python
Designed by Chris Lattner [1]
Developer Modular Inc.
First appeared2023;1 year ago (2023)
Preview release
24.4 [2] / May 24, 2024;3 months 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. [3] [4] [5] It is available both in browsers via Jupyter notebooks, [5] [6] and locally on Linux and macOS. [7] [8] Mojo aims to combine the usability of higher level programming languages, specifically Python, with the performance of system programming languages like C++, Rust, and Zig. [9] The Mojo compiler is currently closed source with an open source standard library, although Modular, the company behind Mojo, has stated their intent to eventually open source the Mojo programming language itself as it matures. [10]

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. [11] [12] 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. [13] [14] According to Jeremy 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. [15]

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. [16] Intention behind Mojo is to bridge the gap between Python’s ease of use and the fast performance required for cutting-edge AI applications. [17]

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

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

Features

Mojo was created for an easy transition from Python. The language has syntax similar to Python's, with inferred static typing, [24] and allows users to import Python modules. [25] It uses LLVM and MLIR as its compilation backend. [5] [26] [27] The language also intends to add a foreign function interface to call C/C++ and Python code. The language is not source-compatible with Python 3, only providing a subset of its syntax, e.g. missing the global keyword, list and dictionary comprehensions, and support for classes. Further, Mojo also adds features that enable performant low-level programming: fn for creating typed, compiled functions and "struct" for memory-optimized alternatives to classes. Mojo structs support methods, fields, operator overloading, and decorators. [6]

The language also provides a borrow checker, an influence from Rust. [28] Mojo def functions use value semantics by default (functions receive a copy of all arguments and any modifications are not visible outside the function), while Python functions use reference semantics (functions receive a reference on their arguments and any modification of a mutable argument inside the function is visible outside). [29]

The language is not open source, but it is planned to be made open source in the future. [30]

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. [31] 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. [32]

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. As it has developed, it has drawn inspiration from other high-level programming languages. Notably, it has been influenced by 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 computer programming, an entry point is the place in a program where the execution of a program begins, and where the program has access to command line arguments.

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.

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.

In certain computer programming languages, data types are classified as either value types or reference types, where reference types are always implicitly accessed via references, whereas value type variables directly contain the values themselves.

<span class="mw-page-title-main">Chris Lattner</span> American software engineer (born 1978)

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 general-purpose programming language emphasizing performance, type safety, and concurrency. It enforces memory safety, meaning that all references point to valid memory. It does so without a traditional garbage collector; instead, both memory safety errors and data races are prevented by the "borrow checker", which tracks the object lifetime of references at compile time.

<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. Notably Julia does not support classes with encapsulated methods and instead it relies on structs with separate functions.

Objective-C is a high-level general-purpose, object-oriented programming language that adds Smalltalk-style message passing (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 language used, supported, and promoted by Apple for developing macOS and iOS applications from 1997, when Apple purchased NeXT until the introduction of the Swift 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 and uses 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.

References

  1. ↑ "How Modular simplified AI software infrastructure". Fast Company. Retrieved 2024-08-19.
  2. ↑ "Mojo Changelog". Modular. Retrieved 2024-04-14.
  3. ↑ "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.
  4. ↑ "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.
  5. 1 2 3 Krill, Paul (4 May 2023). "Mojo language marries Python and MLIR for AI development". InfoWorld.
  6. 1 2 Yegulalp, Serdar (7 June 2023). "A first look at the Mojo language". InfoWorld.
  7. ↑ Deutscher, Maria (7 September 2023). "Modular makes its AI-optimized Mojo programming language generally available". Silicon Angle. Retrieved 2023-09-11.
  8. ↑ "Mojo for Mac OS". Modular. Retrieved 2023-10-19.
  9. ↑ "Mojo 🔥: Programming language for all of AI". www.modular.com. Retrieved 2024-02-28.
  10. ↑ "Modular: The Next Big Step in Mojo🔥 Open Source". www.modular.com. Retrieved 2024-05-28.
  11. ↑ Krill, Paul (2023-05-04). "Mojo language marries Python and MLIR for AI development". InfoWorld. Retrieved 2024-05-28.
  12. ↑ "Should Julia use MLIR in the future?". Julia Programming Language. 2024-02-20. Retrieved 2024-05-28.
  13. ↑ "Why Mojo🔥 | Modular Docs". docs.modular.com. Retrieved 2024-05-28.
  14. ↑ https://llvm.org/devmtg/2023-10/slides/keynote/Mojo.pdf
  15. ↑ Howard, Jeremy (2023-05-04). "fast.ai - Mojo may be the biggest programming language advance in decades". fast.ai. Retrieved 2024-05-28.
  16. ↑ Claburn, Thomas (2023-05-05). "Modular finds its Mojo, a Python superset with C-level speed". The Register. Retrieved 2023-08-08.
  17. ↑ https://venturebeat.com/ai/mojo-rising-the-resurgence-of-ai-first-programming-languages/
  18. ↑ "Mojo🔥 changelog".
  19. ↑ "Modular: A unified, extensible platform to superpower your AI". www.modular.com. Retrieved 2024-04-14.
  20. ↑ "Modular: Mojo🔥 - It's finally here!". www.modular.com. Retrieved 2024-04-14.
  21. ↑ "Modular: Mojo🔥 is now available on Mac". www.modular.com. Retrieved 2024-04-14.
  22. ↑ "Modular open-sources its Mojo AI programming language's core components". SiliconANGLE. 2024-03-28. Retrieved 2024-05-28.
  23. ↑ "mojo/stdlib/README.md at nightly · modularml/mojo". GitHub. Retrieved 2024-05-28.
  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. ↑ Lattner, Chris; Pienaar, Jacques (2019). MLIR Primer: A Compiler Infrastructure for the End of Moore's Law (Technical report). Retrieved 2022-09-30.
  27. ↑ 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].
  28. ↑ "Ownership and borrowing | Modular Docs". Modular. Retrieved 2024-02-29.
  29. ↑ "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 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.
  30. ↑ "Welcome to Mojo 🔥". GitHub . Modular. 2023-10-31. Retrieved 2023-10-31.
  31. ↑ "Modular Docs - Mojo🔥 roadmap & sharp edges". docs.modular.com. Retrieved 2023-10-31.
  32. ↑ "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.