Mojo

https://mojolang.org/
Admin
Mojo is a programming language for artificial intelligence that combines Python's ease of use with...
Tokens:1,266,841
Snippets:11,196
Trust Score:5.4
Update:1 month ago
Show doc for...
Tokens:
Raw
### Examples section usage

Source: https://mojolang.org/docs/reference/docstrings

Shows how to provide practical usage examples for an API using the Examples section.

```mojo
var names: List[String] = ["alice", "bob", "carol"]  
print(names.find("bob").value())  # 1  
print(names.find("dave") is None) # True  
  
var numbers: List[Int] = [1, 2, 3, 4, 3, 9, 3]  
while idx := numbers.find(3):  
    _ = numbers.pop(idx.value())  
print(numbers)  # [1, 2, 4, 9]
```

--------------------------------

### name example

Source: https://mojolang.org/docs/std/pathlib/path/Path

Gets the name of a path and returns 'foo.txt'.

```mojo
from std.pathlib import Path  

  

Path("a/path/foo.txt").name()  # returns "foo.txt"  

```

--------------------------------

### Mojo syntax examples

Source: https://mojolang.org/docs/manual/get-started

Examples of list expressions, compile-time parameters, and run-time arguments.

```mojo
var values: List[Int] = [12, -7, 64]  # This is a list expression
```

```mojo
List[Int]   # List is a standard library-supplied type
Grid[8, 8]  # Grid is a custom type
```

```mojo
print(value)
Grid[8, 8]()
```

--------------------------------

### Install rattler-build globally with Pixi

Source: https://mojolang.org/docs/tools/packaging

Installs rattler-build globally using Pixi.

```bash
pixi global install rattler-build
```

--------------------------------

### Run context manager example normally

Source: https://mojolang.org/docs/manual/errors

Command to run the context_mgr.mojo example without arguments, producing normal output.

```sh
mojo context_mgr.mojo
```

--------------------------------

### Clone Mojo examples repository

Source: https://mojolang.org/docs/manual/basics

Commands to clone the modular GitHub repository and navigate to the Mojo examples directory.

```sh
git clone https://github.com/modular/modular.git
cd modular/Mojo/examples
```

--------------------------------

### Build and run programmatic capture example

Source: https://mojolang.org/docs/manual/errors

Commands to build and run the programmatic capture example with debug symbols enabled.

```sh
mojo build --debug-level full stacktrace_error_capture.mojo
```

```sh
MODULAR_DEBUG=stack-trace-on-error ./stacktrace_error_capture
```

--------------------------------

### Install stable Mojo v1.0.0

Source: https://mojolang.org/releases

Use this package version to install the stable Mojo v1.0.0 release.

```text
mojo==1.0.0
```

--------------------------------

### Install stable Mojo v0.26.1

Source: https://mojolang.org/releases

Use this package version to install the stable Mojo v0.26.1 release.

```text
mojo==0.26.1.0
```

--------------------------------

### Install stable Mojo v1.0.0b1

Source: https://mojolang.org/releases

Use this package version to install the stable Mojo v1.0.0b1 release.

```text
mojo==1.0.0b1
```

--------------------------------

### Install stable Mojo v1.0.0b2

Source: https://mojolang.org/releases

Use this package version to install the stable Mojo v1.0.0b2 release.

```text
mojo==1.0.0b2
```

--------------------------------

### Install stable Mojo v0.26.2

Source: https://mojolang.org/releases

Use this package version to install the stable Mojo v0.26.2 release.

```text
mojo==0.26.2.0
```

--------------------------------

### Install stable Mojo v0.25.6

Source: https://mojolang.org/releases

Use this package version to install the stable Mojo v0.25.6 release.

```text
mojo==0.25.6.0
```

--------------------------------

### Run Mojo with ASSERT=all

Source: https://mojolang.org/docs/tools/feature-toggles

Command-line example showing how to set the ASSERT define to 'all' when running a Mojo program. This enables every debug_assert() call to run.

```sh
mojo run -D ASSERT=all hello.mojo
```

--------------------------------

### Tensor RGB to grayscale conversion example

Source: https://mojolang.org/releases/2023-08

Example from the 2023-08-03 release notes showing how to create a Tensor, fill it with random values, and convert an RGB image to grayscale using the Tensor type. The Tensor type manages its own data, unlike NDBuffer and Buffer which are views.

```Mojo
from tensor import Tensor, TensorShape  

from utils.index import Index  

from random import rand  

  

let height = 256  

let width = 256  

let channels = 3  

  

# Create the tensor of dimensions height, width, channels and fill with  

# random value.  

let image = rand[DType.float32](height, width, channels)  

  

# Declare the grayscale image.  

var gray_scale_image = Tensor[DType.float32](height, width)  

  

# Perform the RGB to grayscale transform.  

for y in range(height):  

    for x in range(width):  

        let r = image[y, x, 0]  

        let g = image[y, x, 1]  

        let b = image[y, x, 2]  

        gray_scale_image[Index(y, x)] = 0.299 * r + 0.587 * g + 0.114 * b  


```

--------------------------------

### Install stable Mojo v0.25.7

Source: https://mojolang.org/releases

Use this package version to install the stable Mojo v0.25.7 release.

```text
mojo==0.25.7.0
```

--------------------------------

### GPU Hello World

Source: https://mojolang.org/docs/tools/notebooks

Demonstrates launching a basic GPU kernel using DeviceContext.

```mojo
%%mojo

from max.gpu.host import DeviceContext

def kernel():
    print("Hello from the GPU")

def main() raises:
    # Launch GPU kernel
    with DeviceContext() as ctx:
        ctx.enqueue_function[kernel](grid_dim=1, block_dim=1)
        ctx.synchronize()
```

```output
Hello from the GPU
```

--------------------------------

### Get base type name with base_name()

Source: https://mojolang.org/docs/manual/metaprogramming/reflection

Uses `reflect[T].base_name()` to get the base type name without parameters. For example, `reflect[List[Int]].base_name()` returns `List`.

```mojo
print(reflect[List[Int]].base_name())          # List
print(reflect[Dict[String, Int]].base_name())  # Dict

```

--------------------------------

### Create test_quickstart.mojo

Source: https://mojolang.org/docs/tools/testing

A basic example of a Mojo test file containing a target function and two test functions, one of which is designed to fail.

```mojo
# Content of test_quickstart.mojo
from std.testing import assert_equal, TestSuite

def inc(n: Int) -> Int:
    return n + 1

def test_inc_zero() raises:
    # This test contains an intentional logical error to show an example of
    # what a test failure looks like at runtime.
    assert_equal(inc(0), 0)

def test_inc_one() raises:
    assert_equal(inc(1), 2)

def main() raises:
    TestSuite.discover_tests[__functions_in_module()]().run()
```

--------------------------------

### Install nightly Mojo package version

Source: https://mojolang.org/releases

Use this package version to install the nightly build of Mojo. The nightly build includes new features but is not complete and may have new bugs.

```text
mojo==1.2.0.dev2026091705
```

--------------------------------

### suffix example

Source: https://mojolang.org/docs/std/pathlib/path/Path

Gets the file extension and asserts it equals '.txt' for a file, and an empty string for a hidden file.

```mojo
from std.pathlib import Path  

from std.testing import assert_true  

  

var p = Path("testfile.txt")  

print(p.suffix())  

assert_true(p.suffix() == ".txt")  

  

p = Path(".hiddenfile")  

assert_true(p.suffix() == "") # No suffix  

```

--------------------------------

### Make List

Source: https://mojolang.org/docs/reference/cheat-sheets/conversions

Create and initialize a List.

```mojo
var x: List[T] = [a, b, c] # annotate: unannotated defaults to Array  

List[T](capacity=n) # empty; initial room for n  

List[T](length=n, fill=x) # n copies of x (T: Copyable)  

List(range(n)) # materialize a range  

List(iterable) # from any iterator / iterable  
```

--------------------------------

### expanduser() and home() example

Source: https://mojolang.org/docs/std/pathlib/path/Path

Expands a tilde path and asserts it equals the home directory.

```mojo
from std.pathlib import Path  

from std.testing import assert_true  

  
var p = Path("~")  

assert_true(p.expanduser() == Path.home())  
```

--------------------------------

### BitSet usage example

Source: https://mojolang.org/docs/std/collections/bitset

Shows how to create a 128-bit BitSet, set and test a value, clear it, and get the population count. The example prints "hit" when testing value 42 and prints 0 after clearing.

```python
from std.collections import BitSet  

var bs = BitSet[128]()  # 128-bit set, all clear  
bs.set(42)              # Mark value 42 as present.  
if bs.test(42):         # Check membership.  
    print("hit")        # Prints "hit".  
bs.clear(42)            # Remove 42.  
print(len(bs))          # Prints 0.  
```

--------------------------------

### Install stable Mojo v1.1.0

Source: https://mojolang.org/releases

Use this package version to install the stable Mojo v1.1.0 release, which is the latest stable version as of Sep 17, 2026.

```text
mojo==1.1.0
```

--------------------------------

### Get function display name with reflect_fn

Source: https://mojolang.org/docs/std/reflection/function/ReflectedFn

Shows how to use the reflect_fn handle to get the display name of a function. The example defines a function my_func and prints its name using reflect_fn[my_func].display_name(). The output is "my_func".

```mojo
from std.reflection import reflect_fn  

  

def my_func(x: Int) -> Int:  
    return x  
  

def main():  
    print(reflect_fn[my_func].display_name())  # "my_func"  

```

--------------------------------

### Mojo: Read integer define with default value using get_defined_int[]()

Source: https://mojolang.org/docs/tools/feature-toggles

Shows how to get an integer compile-time define with a default value. The default is returned only if the define is missing; if the define exists but is not a valid base-10 integer, compilation still fails.

```sh
mojo -D max_threads=8 app.mojo
```

```mojo
from std.sys import get_defined_int

def main():
    comptime threads = get_defined_int["max_threads", 4]()
    print("using", threads, "threads")
```

--------------------------------

### Launch Mojo REPL

Source: https://mojolang.org/docs/cli/repl

The basic syntax for starting the Mojo REPL environment.

```bash
mojo repl [lldb-options]
```

--------------------------------

### Example: Using reflect and get_function_name

Source: https://mojolang.org/docs/std/reflection/type_info

Shows how to get a type's name with reflect[Point].name() and a function's source name with get_function_name[my_function](). The example defines a struct Point and a function my_function, then prints both names in main().

```mojo
from std.reflection import reflect, get_function_name  

  

struct Point:  

    var x: Int  

    var y: Float64  

  

def my_function():  

    pass  

  

def main():  

    print(reflect[Point].name())             # "Point"  

    print(get_function_name[my_function]())  # "my_function"  

```

--------------------------------

### Placement delete with __get_address_as_owned_value

Source: https://mojolang.org/releases/2023-04

Demonstrates the `__get_address_as_owned_value` builtin for low-level ownership muckery. It takes a pointer and returns an owned value, which must be consumed or it will be automatically destroyed. The example shows both discarding the value and passing it to a consuming function.

```mojo
# "Placement delete": destroy the initialized object begin pointed to.  
_ = __get_address_as_owned_value(somePointer.value)  

  
# Result value can be consumed by anything that takes it as an 'owned'  
# argument as well.  
consume(__get_address_as_owned_value(somePointer.value))  

```

--------------------------------

### __getitem__(self, *, codepoint: ContiguousSlice) -> Self

Source: https://mojolang.org/docs/std/collections/string/string_span/StringSpan

Gets a substring at the specified codepoint positions. Aborts if the slice is out of bounds or start is greater than end.

```APIDOC
## __getitem__(self, *, codepoint: ContiguousSlice) -> Self

### Description
Gets a substring at the specified codepoint positions. Aborts if `codepoint`'s start or end index is out of bounds (valid range is `0` to `self.count_codepoints()`, inclusive), or if start is greater than end. Negative indices are not supported and always abort.

### Method
__getitem__

### Parameters
#### Args
- **codepoint** (ContiguousSlice) - Required - A slice that specifies codepoint positions of the new substring.

### Returns
Self: A new StringSpan containing the codepoints in the specified range.
```

--------------------------------

### Hello Mojo example

Source: https://mojolang.org/docs/tools/notebooks

A basic Mojo program using the %%mojo directive and a main function.

```mojo
%%mojo

def main():
  print("Hello Mojo")
```

```output
Hello Mojo
```

--------------------------------

### Invalid Decorator Ordering

Source: https://mojolang.org/releases/2023-07

Shows an invalid example where a signature decorator is applied after a body decorator, which is prohibited in Mojo.

```mojo
@register_passable # error: cannot apply signature decorator after a body one!

@value

struct Foo:

    pass
```

--------------------------------

### Basic function declaration with def

Source: https://mojolang.org/docs/reference/function-declarations

Starts a function declaration with the `def` keyword. The example defines `greet` that takes a `String` argument and returns a `String`.

```mojo
def greet(name: String) -> String:  

    return "Hello, " + name  

```

--------------------------------

### Pipe usage example

Source: https://mojolang.org/docs/std/os/process/Pipe

Demonstrates how to initialize a Pipe and write bytes to it.

```mojo
from std.os.process import Pipe  

  

def main() raises:  

    var pipe = Pipe()  

    pipe.write_bytes("TEST".as_bytes())
```

--------------------------------

### Using reflect_fn to display name of add function

Source: https://mojolang.org/docs/std/reflection/function

Example of using `reflect_fn[add]` to get the display name of a function. Requires importing `reflect_fn` from `std.reflection`.

```mojo
from std.reflection import reflect_fn  

def add(a: Int, b: Int) -> Int:  
    return a + b  

def main():  
    print(reflect_fn[add].display_name())  # "add"  
```

--------------------------------

### Instantiate and use a struct

Source: https://mojolang.org/docs/manual/basics

Example of creating an instance of MyPair and calling its dump method.

```mojo
def use_mypair():
    var mine = MyPair(2, 4)
    mine.dump()
```

--------------------------------

### Mojo: Read required integer compile-time define with get_defined_int[]()

Source: https://mojolang.org/docs/tools/feature-toggles

Shows how to get a required integer value from a compile-time define. Compilation fails if the define is missing or the value is not a valid base-10 integer. Invalid formats like 0x10, 0o10, or 1_000 cause errors.

```sh
mojo -D max_threads=8 app.mojo
```

```mojo
from std.sys import get_defined_int

def main():
    comptime threads = get_defined_int["max_threads"]()
    print(t"Up to {threads} threads")
```

--------------------------------

### Use source_location to get the location of the call

Source: https://mojolang.org/docs/manual/metaprogramming/reflection

Shows how source_location() returns the location where it is called, not the caller's location. The example logs the file name and line number of the log call itself.

```mojo
from std.reflection import source_location

def log(msg: String):
    var loc = source_location()
    print(
        "[", loc.file_name(), ":", loc.line(), "] ",
        msg, sep=""
    )

def main():
    log("starting up")
    # [/path/to/file.mojo:4:15] starting up
```

--------------------------------

### Examples of String.format() usage

Source: https://mojolang.org/docs/std/collections/string/format

Shows basic formatting, multiple arguments, and conversion flags with expected outputs in comments.

```mojo
# Basic formatting  
var s1 = "Hello {0}!".format("World")  # Hello World!  

# Multiple arguments  
var s2 = "{0} plus {1} equals {2}".format(1, 2, 3)  # 1 plus 2 equals 3  

# Conversion flags  
var s4 = "{!r}".format("test")  # "'test'"
```

--------------------------------

### @value decorator on struct

Source: https://mojolang.org/releases/2023-04

The @value decorator synthesizes fieldwise __init__, __copyinit__, and __moveinit__ methods for structs with value semantics, reducing boilerplate. The source shows the example struct definition followed by the synthesized methods.

```mojo
@value  

struct MyPet:  

  var name: String  

  var age: Int  



```

```mojo
fn __init__(inout self, owned name: String, age: Int):  

    self.name = name^  

    self.age = age  

fn __copyinit__(inout self, existing: Self):  

    self.name = existing.name  

    self.age = existing.age  

fn __moveinit__(inout self, owned existing: Self):  

    self.name = existing.name^  

    self.age = existing.age  



```

--------------------------------

### Allocate, use, and free storage with Allocation

Source: https://mojolang.org/docs/std/memory/alloc

Demonstrates allocating memory for four strings, initializing them, printing the values, and manually deinitializing and deallocating the storage.

```mojo
from std.memory.alloc import alloc, dealloc, Layout  

from std.memory import unsafe_destroy_n  

  

var allocation = alloc(Layout[String](count=4))  

var ptr = allocation.unsafe_ptr()  

  

# initialize the memory  

for i in range(allocation.layout().count()):  

    ptr.unsafe_offset(i).unsafe_write("🔥")  

  

# print the values  

for string in allocation.unsafe_span():  

    print(string) # prints "🔥"  

  

# deinitialize the values  

unsafe_destroy_n(allocation.unsafe_ptr(), allocation.layout().count())  

  

# deallocate the memory  

dealloc(allocation^)
```

--------------------------------

### Use type_of to get the type of an expression

Source: https://mojolang.org/docs/manual/metaprogramming/reflection

Demonstrates using type_of(x) in a parameter position to create a default value of the same type as x. The example prints 0 for an Int variable.

```mojo
def make_default[T: Defaultable]() -> T:
    return T()

def main():
    var x = 42
    var y = make_default[type_of(x)]()
    print(y)  # 0
```

--------------------------------

### Nested function default closure behavior change

Source: https://mojolang.org/releases/2023-04

Nested functions that capture are now non-parametric, runtime closures by default. Captured values are copied and immutable; the example shows that the nested function is equivalent to a lambda. Non-capturing functions remain parametric by default.

```mojo
def foo(x):  

    # This:  

    def bar(y): return x * y  

    # Is the same as:  

    let bar = lambda y: x * y  



```

--------------------------------

### Print field count of a struct using reflect[Point].field_count()

Source: https://mojolang.org/docs/std/reflection/reflect

Shows how to get the number of fields in a struct type with `reflect[Point].field_count()`. The example prints the count, which is 2 for the `Point` struct.

```mojo
struct Point:  

    var x: Int  

    var y: Float64  

  

def main():  

    print(reflect[Point].field_count())  # 2  
```

--------------------------------

### Use String properties, indexing, search, replace, and format

Source: https://mojolang.org/docs/std/collections/string/string/String

Comprehensive example covering byte indexing, in-place concatenation, membership testing, find(), replace(), and format(). Outputs include byte_length()=5, byte slices, "Hello World", found messages, "Hi World", and "Alice is 30 years old".

```mojo
var text = "Hello"

# String properties and indexing
print(text.byte_length())                 # 5
print(text[byte=1])                       # e (byte slice)
print(text[byte=text.byte_length() - 1])  # o (last character)

# In-place concatenation
text += " World"
print(text)

# Searching and checking
if "World" in text:
    print("Found 'World' in text")

var pos = text.find("World")
if pos != -1:
    print("'World' found at position:", pos)

# String replacement
var replaced = text.replace("Hello", "Hi")   # "Hi World"
print(replaced)

# String formatting
var name = "Alice"
var age = 30
var formatted = "{} is {} years old".format(name, age)
print(formatted)    # "Alice is 30 years old"
```

--------------------------------

### Manual installation via GitHub CLI

Source: https://mojolang.org/docs/tools/skills

Clones the modular/skills repository using the GitHub CLI.

```text
gh repo clone modular/skills
```

--------------------------------

### Retrieve and print command line arguments using argv()

Source: https://mojolang.org/docs/std/sys/arg/argv

Imports `argv` from `std.sys` and uses it in `main()` to get a span of arguments. Iterates over the span and prints each argument. This is the core example for accessing CLI arguments in Mojo.

```mojo
from std.sys import argv


def main() raises:
    args = argv()
    for arg in args:
        print(arg)

```

--------------------------------

### String literal forms

Source: https://mojolang.org/docs/reference/literals

Shows single-quoted, double-quoted, and triple-quoted string literals. Triple-quoted strings include newlines literally; the first example includes a final newline, and the second includes four spaces at the start of the second line.

```mojo
"Hello"  

'world'  

"""Multi-line  

string  

"""                # Includes final newline  

'''Also  

    multi-line'''  # Includes 4 spaces at the start of the second line  
```

--------------------------------

### Docstring example with Parameters, Args, and Returns

Source: https://mojolang.org/community/contributing/stdlib/stdlib-code-style

Shows the Google-style docstring format used in the Mojo standard library, including Parameters, Args, and Returns sections.

```mojo
def add_param_arg[foo: Int](https://mojolang.org/community/contributing/stdlib/bar: Int.md) -> Int:
    """[summary].

    Parameters:
        foo: [description].

    Args:
        bar: [description].

    Returns:
        [description].
    """
    return foo + bar
```

--------------------------------

### run

Source: https://mojolang.org/docs/std/benchmark/quick_bench/QuickBench

Documentation for the `run` method of the QuickBench class, which benchmarks a function with 10 input arguments.

```APIDOC
## `run`

### Description
Benchmark function `func` with 10 input arguments and return type `T_out`.

### Method
`run`

### Signature
`def run[T0: TrivialRegisterPassable, T1: TrivialRegisterPassable, T2: TrivialRegisterPassable, T3: TrivialRegisterPassable, T4: TrivialRegisterPassable, T5: TrivialRegisterPassable, T6: TrivialRegisterPassable, T7: TrivialRegisterPassable, T8: TrivialRegisterPassable, T9: TrivialRegisterPassable, /, T_out: TrivialRegisterPassable](mut self, func: def(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) thin -> T_out, x0: T0, x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, *, bench_id: BenchId, measures: List[ThroughputMeasure] = List())`

### Parameters
#### Type Parameters
- **T0** (`TrivialRegisterPassable`) - Type of the 1st argument of func.
- **T1** (`TrivialRegisterPassable`) - Type of the 2nd argument of func.
- **T2** (`TrivialRegisterPassable`) - Type of the 3rd argument of func.
- **T3** (`TrivialRegisterPassable`) - Type of the 4th argument of func.
- **T4** (`TrivialRegisterPassable`) - Type of the 5th argument of func.
- **T5** (`TrivialRegisterPassable`) - Type of the 6th argument of func.
- **T6** (`TrivialRegisterPassable`) - Type of the 7th argument of func.
- **T7** (`TrivialRegisterPassable`) - Type of the 8th argument of func.
- **T8** (`TrivialRegisterPassable`) - Type of the 9th argument of func.
- **T9** (`TrivialRegisterPassable`) - Type of the 10th argument of func.
- **T_out** (`TrivialRegisterPassable`) - Output type of func.

#### Arguments
- **func** (`def(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) thin -> T_out`) - The function to be benchmarked (run in benchmark iterations).
- **x0** (`T0`) - The 1st argument of func.
- **x1** (`T1`) - The 2nd argument of func.
- **x2** (`T2`) - The 3rd argument of func.
- **x3** (`T3`) - The 4th argument of func.
- **x4** (`T4`) - The 5th argument of func.
- **x5** (`T5`) - The 6th argument of func.
- **x6** (`T6`) - The 7th argument of func.
- **x7** (`T7`) - The 8th argument of func.
- **x8** (`T8`) - The 9th argument of func.
- **x9** (`T9`) - The 10th argument of func.
- **bench_id** (`BenchId`) - The benchmark Id object used for identification.
- **measures** (`List[ThroughputMeasure]`) - Optional arg used to represent a list of ThroughputMeasure's.

### Raises
If the operation fails.
```

--------------------------------

### pixi.toml channels configuration for modular-community

Source: https://mojolang.org/docs/tools/packaging

Example pixi.toml manifest showing the channels list that includes the modular-community channel (https://repo.prefix.dev/modular-community) alongside the Mojo nightly channel and conda-forge. Add this channel to your project manifest to install packages published to the channel.

```toml
[workspace]
channels = [
  "https://conda.modular.com/max-nightly",
  "https://repo.prefix.dev/modular-community",
  "conda-forge",
]
```
Tokens:
Raw