Mojo reference

This section includes the Mojo API references:

Standard library: Common Mojo APIs.
MAX AI Kernels library. Mojo APIs for writing high-performance computational kernels and custom operations for AI models.
MAX library. MAX Mojo APIs, including tensor APIs for custom operations, and legacy MAX APIs.
Decorators. Mojo decorators reference.

How to read the Mojo API docs

Mojo syntax is covered in detail in the Mojo manual. Here's a quick cheat-sheet on reading struct and function signatures.

Arguments

Function arguments appear in parentheses after the function name:

fn example_fn(pos: Int, /, pos_or_kw: Int, *, kw_only: Bool = False):
    ...
fn example_fn(pos: Int, /, pos_or_kw: Int, *, kw_only: Bool = False):
    ...

Here's a quick overview of some special syntax in the argument list:

Slash (/): arguments declared before a slash are positional-only arguments.
Star (*): a star by itself in place of an argument indicates that the arguments after the star are keyword-only.
An equals sign (=) introduces a default value for an optional argument.

You may also see argument names prefixed with one or two stars (*):

def myfunc2(*names, **attributes):
def myfunc2(*names, **attributes):

An argument name prefixed by a single star character, like *names identifies a variadic argument.
An argument name prefixed with a double star, like **attributes identifies a variadic keyword-only argument.

An argument may also be preceded by an argument convention, which indicates how the value is passed:

fn sort(mut names: List[String]):
fn sort(mut names: List[String]):

The most common conventions are:

read(default): the callee receives an immutable reference to the value.
mut: the callee receives a mutable reference to the value.
owned: the callee receives ownership of a value.

For details and a complete list of argument conventions, see Argument conventions.

Parameters

Mojo structs and functions can take parameters. Parameters are evaluated at compilation time, and act as constants at runtime. Parameter lists are enclosed in square brackets:

struct ExampleStruct[size: Int, //, thing: Thing[size]]:
struct ExampleStruct[size: Int, //, thing: Thing[size]]:

Parameters that occur before a double-slash (//) in the parameter list are infer-only parameters. You usually don't need to specify infer-only parameters; as the name suggests, they're usually inferred.

Like arguments, parameters can be positional-only, keyword-or-positional, or keyword-only, and they can be required or optional. The /, *, and = characters have the same meaning in parameter lists as they do in argument lists.

Standard library

The Mojo standard library provides nearly everything you'll need for writing Mojo programs, including basic data types like Int and SIMD, collection types like List, reusable algorithms and modules to support GPU programming.

Top-level packages:

algorithm

Implements the algorithm package.

base64

Implements the base64 package.

benchmark

Implements the benchmark package for runtime benchmarking.

bit

Implements the bit package.

buffer

Implements the buffer package.

builtin

Implements the builtin package.

collections

Implements the collections package.

compile

Provides utilities for compiling and inspecting Mojo code at runtime.

complex

Provides types and functions for working with complex numbers.

documentation

Implements the documentation package.

gpu

Provides low-level programming constructs for working with GPUs.

hashlib

Implements the hashlib package that provides various hash algorithms.

logger

Provides logging functionality with different severity levels.

math

Implements the math package.

memory

The memory package provides several pointer types, as well as utility functions for dealing with memory.

Provides access to operating-system dependent functionality.

pathlib

Implements the pathlib package.

prelude

Implements the prelude package. This package provide the public entities that are automatically imported into every Mojo program.

pwd

Provides access to user and group information from the password database.

python

Implements the python package.

random

Implements the random package.

runtime

Implements the runtime package.

stat

Implements the stat package.

subprocess

Implements the subprocess package.

sys

Implements the sys package.

tempfile

Implements the tempfile package.

testing

Implements the testing package.

time

Implements the time package.

utils

Implements the utils package.

MAX AI kernels library

The MAX AI kernels library provides a collection of highly optimized, reusable compute kernels for high-performance numerical and AI workloads. These kernels serve as the foundational building blocks for writing MAX custom operations or standalone GPU kernels that are portable across CPUs and GPUs.

Top-level packages:

kv_cache

Contains implementations for several types of key-value caches.

layout

Provides layout and layout tensor types, which abstract memory layout for multidimensional data.

linalg

Provides CPU and GPU implementations of linear algebra functions.

Provides neural network operators for deep learning models.

nvml

Implements wrappers around the NVIDIA Management Library (nvml).

quantization

This package contains a set of APIs for quantizing tensor data.