Mojo reference
This section includes the Mojo API references:
- Standard library: Common Mojo APIs.
- Kernels library. Mojo APIs for writing high-performance computational kernels and custom operations.
- 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
base64
benchmark
bit
buffer
builtin
collections
compile
complex
gpu
hashlib
logger
math
memory
os
pathlib
pwd
python
random
runtime
stat
subprocess
sys
tempfile
testing
time
utils
Kernels library
The Mojo kernels library provides APIs for writing computational kernels that run on CPU and GPU. You can use these APIs when developing MAX custom operations or standalone GPU kernels.
Top-level packages:
layout
register
MAX library
The Mojo MAX library provides APIs to interact with the MAX graph compiler and runtime.
Top-level packages:
driver
max.driver
Mojo API is being deprecated in favor of the open source gpu.host
API, which has better ergonomics, and is more feature complete.engine
graph
tensor
Decorators
A Mojo decorator is a higher-order function that modifies or extends the behavior of a struct, a function, or some other code.
@__copy_capture
@always_inline
@compiler.register
@implicit
@nonmaterializable
@parameter
@register_passable
@staticmethod
@value
Was this page helpful?
Thank you! We'll create more content like this.
Thank you for helping us improve!