Modular has rolled out a new language called Mojo that combines the simplicity of Python with the speed and safety of Rust. Now, users can run Mojo locally, not just in online environments. This is a big step for developers interested in low-level programming with a familiar feel.

Getting to Know Mojo and Its Goals

When Mojo was first announced, many thought of it as an extension of Python. It looked similar and even allowed some code to run in both languages. But that’s not quite the case. Mojo’s main goal isn’t to run existing Python code. Instead, it offers a syntax that’s easy for Python users but adds features suited for lower-level tasks, like manual memory management. This makes it more powerful for performance-critical applications.

One of Mojo’s standout features is that it is compiled ahead of time into machine code using LLVM. This means Mojo programs generally run faster than Python scripts, especially when using Mojo-specific features. Python’s dynamic typing and flexible features can slow things down, but Mojo’s design emphasizes speed and efficiency. It also supports large integers up to 256 bits, which are optimized using SIMD instructions, making mathematical operations faster.

How Mojo Looks and Acts Like Python

For Python developers, Mojo feels familiar at first glance. The syntax uses indentation and straightforward structures. But there are important differences. In Mojo, you declare variables explicitly with the keyword var. This clarifies scope and helps with performance. For example, variables inside an if block in Mojo are limited to that block, unlike Python where they can leak outside.

Mojo also introduces a new way to define data structures. Instead of classes like in Python, Mojo uses structs, similar to C or Rust. These are fixed in layout, which boosts speed. Functions can be declared with either def or fn. The latter is used for internal functions that handle errors on their own, avoiding extra runtime checks that could slow things down.

Here’s a quick example of a simple structure in Mojo:

struct Point:
  var x: Int
  var y: Int
  fn __init__(out self, x: Int, y: Int)
    self.x = x
    self.y = y

Notice how similar it looks to Python, but with some key differences in syntax and behavior.

Using Mojo and Python Together

If you want to try Mojo on your machine, you can download the binaries for Mac or Linux. Windows users can run Mojo using WSL2. For Python users, the easiest way is to set up a virtual environment and install Mojo like a Python package. This makes it simple to switch between the two languages and use third-party Python libraries within Mojo projects.

Running Mojo scripts is straightforward. Save your code with a .mojo extension and run it with the mojo command. For faster execution, you can compile your code into a binary with mojo build, which produces a compact standalone file. For example, a simple “Hello, World” program on Linux compiles into a 19 KB binary.

Mojo’s project management also plays nicely with tools like Modular’s pixi. You can manage Mojo projects or mix Mojo with Python, thanks to support for Python’s project files like pyproject.toml. This flexibility makes it easier to integrate Mojo into existing workflows.

Bridging Python and Mojo

When writing Mojo code, the default is that everything is Mojo. But if you want to use Python features, you need to import them explicitly. For example, you can import NumPy like this:

from python import Python

def main():
  np = Python.import_module("numpy")
  rand_array = np.random.rand(32)

This import system connects Mojo to Python’s ecosystem, allowing access to all standard and third-party libraries installed in your virtual environment.

However, there are some limitations. You can’t import modules at the top level of a Mojo file, and some Python import behaviors aren’t supported yet. Also, every time Mojo calls Python code, it incurs a performance cost because of the crossing boundary. To keep things fast, it’s best to minimize these calls or batch operations when possible.

Interestingly, Mojo can also be invoked from Python, but the setup is more involved. This allows Python programs to use Mojo modules, creating a two-way bridge. It’s a useful feature for those wanting to combine Python’s flexibility with Mojo’s speed in the same project.

Overall, Mojo is shaping up as an exciting tool for developers who want low-level control without losing the ease of a Python-like syntax. Its ability to compile into native code and work seamlessly with Python makes it a promising addition to the programming landscape.

Inspired by

• https://www.infoworld.com/article/4081105/revisiting-mojo-a-faster-python.html

Sources

• gmpg.org
• modular.com
• pixi.sh
• modular.com
• modular.com