@Modular: Session 1 of Mojo 101 streamed yesterday, and the turnout was great. Our live chat was full of insightful questions. If…

Session 1 of Mojo 101 streamed yesterday, and the turnout was great. Our live chat was full of insightful questions.

If you missed it (or want to rewatch), the recording of Language Fundamentals is up now on YouTube: https://t.co/xkmcNOk0hm

TL;DR

Mojo 101 Session 1 covers setting up a Mojo project with Pixie, writing a “hello world” program, and understanding why Mojo’s compilation, static typing, and ownership model make it a powerful language for performance‑sensitive work.

Lesson Introduction and Goals

Michael Dun Connor, Developer Advocate at Modular, introduces the four‑part Mojo 101 series. The overall aim is to take learners from “hello world” to GPU programming, building on the existing Mojo GPU puzzles resource. By the end of the series, participants should be able to:

• Start parallel programming in Mojo on their own.
• Apply Mojo to their own domain problems.
• Contribute to the open‑source Mojo standard library and kernel projects.

Session 1 focuses on language fundamentals: creating a Mojo project, functions, control flow, and structs.

Creating a Mojo Project with Pixie

Pixie is used as the package manager. The steps are:

1. Install Pixie (if not already installed) using the curl command from the Mojo quick‑start guide.
2. Initialise a project:

   pixie init session_one
   cd session_one
   

   This creates a directory with a pixie.lock file (dependencies initially empty).
3. Add the Mojo dependency:

   pixie add mojo
   

   This installs Mojo 1.0 beta 2 (the version used in the session).
4. Enter the Pixie virtual environment:

   pixie shell
   

   Verify with mojo --version – it should print “Mojo 1.0 beta 2”.

Hello World and Two Ways to Run

Create a file hello.mojo with the following content:

# This is a comment
def main():
    print("hello world!")

The entry point must be a function named main.

Running the Code

Immediate compile‑and‑run:

mojo hello.mojo

Output: hello world!

Pre‑compile to a binary:

mojo build hello.mojo

This produces an executable named hello. Run it with ./hello. The compiled binary runs even outside the Pixie environment – demonstrating a key advantage of compiled languages.

Why Mojo? Compilation, Static Typing, and Ownership

Nate from the Mojo standard library team explains three core concepts that set Mojo apart.

Compiled vs. Interpreted Languages

Mojo is compiled, not interpreted like Python. The two‑step process (compile → binary) allows the compiler to optimise the code for the target hardware, resulting in very fast execution. The binary can be run without the original source or even the Mojo toolchain, as shown with the ./hello example.

Static Typing

Every variable and function parameter must have a known type at compile time. Mojo can infer the type from the initial value, or you can explicitly annotate it.

var x: Int = 42   # explicit type annotation

Because types are fixed, the compiler catches mismatches early. For instance, assigning a string to an integer variable produces a compile‑time error: “cannot implicitly convert ‘String’ to ‘Int’”. Similarly, a function that expects an Int argument cannot be called with a String.

Functions require explicit parameter and return types:

def add_one(x: Int) -> Int:
    return x + 1

Omitting the return type leads to an error: “cannot implicitly convert ‘Int’ to ‘None’”. This strictness eliminates an entire class of runtime type errors common in dynamic languages.

Ownership and Memory Safety

Mojo uses a value‑semantics ownership model (similar to Rust). An example illustrates the difference:

var a = "hello"
var b = a   # b is a *copy* of a
b += " world"
print(a)   # outputs "hello"
print(b)   # outputs "hello world"

Here a and b are separate instances. Modifying b does not affect a – a key distinction from languages where assignment creates a reference. This ownership system prevents accidental aliasing and makes memory management predictable.

Next Steps and QA

The session concluded with a brief open Q&A (team members answered live chat questions). Future sessions will follow the same structure: a topic overview, live coding, and a Q&A segment.

Source: YouTube video – @Modular: Session 1 of Mojo 101