Compilation targets docs instructs how to inspect your current platform, select a target configuration, and generate code for that target. Use it to build for your own system or target other CPUs, operating systems, and accelerators.
Mojo language reference covers lexical elements, expressions, statements, numeric types, struct declarations, trait declarations.
Functions reference page improves discoverability of new function features.
Split operators manual into separate pages; refreshed coverage and added tutorial, operator tests, and new reference page.
Negative examples and errors added to reference pages highlight sharp edges of the language.
MLIR reference page introduces inline MLIR to developers in Mojo code.
Adds docs for non-nullable pointers and provides sample code showing
how to use Optional with UnsafePointer.
Separated the Mojo layout library docs from the MAX kernels library,
reflecting that the layout library ships with the mojo package while the
rest of the kernels library ships with the max package.
Added a new guide for building Mojo packages, currently covering the
rattler-build workflow.
Restructured the Mojo and MAX system requirements and GPU compatibility docs. Replaced the three-tier GPU support model with a two-level "Continuously tested" / "Known compatible" taxonomy, added a dedicated Mojo GPU compatibility page with per-vendor hardware tables and driver requirements, and simplified the main requirements pages.
Added a Mojo manual reference page for the @doc_hidden decorator.
Added type refinement based on compile time assumptions, enabling Mojo to
narrow types from where clauses, comptime if statements, and
comptime assert statements. Refinements in a scope are driven by
conforms_to() expressions.
Before:
def __contains__(self, value: Self.T) -> Bool where conforms_to(Self.T, Equatable):
for item in self:
if trait_downcast[Equatable](item) == trait_downcast[Equatable](value):
return True
return False
After:
def __contains__(self, value: Self.T) -> Bool where conforms_to(Self.T, Equatable):
for item in self:
if item == value:
return True
return False
Improved diagnostics for onboarding-priority parser errors in Mojo for clarity and UX.
Updated signature error diagnostics and added related tests.
Mojo now uses NoneType instead of an empty tuple to mark constructor
using literals.
The ternary if/else expression now coerces each element to its contextual
type when it is obvious. For example, this works instead of producing an
error about incompatible metatypes:
comptime some_type: Movable = Int if cond else String
Unified closure improvements. This release continues the closure
unification work begun in earlier releases: stateless closures auto-lift,
the ref capture convention is supported, default capture conventions can
be combined with explicit capture lists, and a new thin function effect
distinguishes function pointer types from closure traits.
def main() raises:
var a, b, c, d = 1, 2, 3, 4
var x = "hello"
# Legacy closure: no capture list. Cannot capture variables.
def hello():
print("hi")
# Unified closure with no captures (stateless). Stateless closures
# lift to top-level functions and can be passed as FFI callbacks.
def add_one(n: Int) {} -> Int:
return n + 1
# Unified closure with explicit captures and a default capturing
# convention:
def my_fn() {mut a, b, c^, read}:
# capture:
# `a` by mut reference
# `b` by immut reference
# `c` by moving
# `d` by immut reference (the default `read` convention)
use(a, b, c, d)
# Unified closure that captures `x` by ref (carries an
# origin-mutability parameter):
def show_x() {ref x}:
print(x)
# Function effects come before the capture list. The calling context
# must handle errors raised from a `raises` closure.
def fallible() raises {}:
raise Error("nope")
# Closures are invoked like ordinary functions:
hello()
print(add_one(41))
my_fn()
show_x()
try:
fallible()
except e:
print(e)
# The `thin` function effect declares a function pointer type
# (distinct from a closure trait). Stateless closures and top-level
# functions satisfy `thin`:
var fn_ptr: def(Int) thin -> Int = add_one
print(fn_ptr(99))
Added abi("C") as a function effect for declaring C calling convention on
function definitions and function pointer types. Functions marked with
abi("C") use the platform C ABI (System V x86-64 / ARM64 AAPCS) for
struct arguments and return values, enabling safe interop with C libraries:
# C-ABI function definition (safe as a callback into C code)
def add(a: Int32, b: Int32) abi("C") -> Int32:
return a + b
# C-ABI function pointer type (safe for use with DLHandle.get_function)
var f = handle.get_function[def(Float64) abi("C") -> Float64]("sqrt")
DLHandle.get_function[] now enforces that the type parameter carries
abi("C"), preventing silent ABI mismatches when loading C symbols.
String literals now support \uXXXX and \UXXXXXXXX unicode escape
sequences, matching Python. The resulting code point is stored as UTF-8.
Invalid code points and surrogates are rejected at parse time.
Added support for conditional RegisterPassable conformance.
Variadic lists and packs can be forwarded through runtime calls with *pack
when the callee takes a compatible variadic list/pack.
def callee[*Ts: Writable](*args: *Ts):
comptime for i in range(args.__len__()):
print(args[i])
def forwarder[*Ts: Writable](*args: *Ts):
callee(*args)
forwarder(1, "hello", 3.14) # prints each value on a separate line
Heterogenous variadic packs can now be specified with a SomeType helper
function. These two are equivalent:
def foo[*arg_types: Copyable](*args: *arg_types) -> Int: ...
def foo(*args: *SomeTypeList[Copyable]) -> Int: ...
T-strings can now be used in comptime assert messages:
def foo[i: Int]():
comptime assert i > 5, t"expected i > 5, got {i}"
Added __mlir_deferred_type[...] for declaring parameter-dependent return
types and operation result types in inline MLIR. The parser combines the
bracketed pieces into a type string and the elaborator builds the concrete
MLIR type once parameters are substituted.
Variadic parameters lists are now passed instead of ParameterList and
TypeList instead of !kgen.param_list. This makes it much more ergonomic to
work with these types, e.g. simple logic just works:
def callee[*values: Int]():
var v = 0
for i in range(len(values)):
v += values[i]
for elt in values:
v += elt
Similarly, the ParameterList/TypeList structs have other methods for
transforming the value list. As such, a variety of values from the Variadic
struct have started moving over to being members of these types.
All Mojo functions now has a unique "function literal type". In practice, it means that:
# type_of(foo) != type_of(bar)
def foo(): pass
def bar(): pass
The fn keyword for function declarations is deprecated. Mojo now emits a
compiler warning on uses of fn; this will become a compilation error in
the next release. Use def instead.
The unified keyword has been removed; specify unified-closure semantics
with an explicit capture list {...} after the function signature. An
empty capture list {} denotes unified with no captures. Closures without
any capture list are legacy. Mojo also now warns when a function pointer
type omits the thin effect; specify thin explicitly to silence the
warning.
Removed support for comparing tuples of differing lengths or types. Such
comparisons (for example (1, 2) != (4, 5, 6)) are now rejected statically
by the type system instead of silently returning not-equal.
A if comptime(C) else B now skips elaboration of the dead branch,
treating the ternary expression as a compile-time evaluation contract
analogous to comptime if C: A else: B.
@explicit_destroy is now rejected at parse time when paired with an
unconditional ImplicitlyDestructible conformance; it remains valid only
on conditional (where-clause-constrained) conformances.
Import statements of the form from pkg import ... no longer make pkg
available to the module.
Removed explicit trait_downcast/trait_downcast_var across the standard
library sources, now that Mojo applies type refinement from comptime
assumptions. Public APIs are unchanged. Updated files:
stdlib/std/builtin/: _stubs.mojo, bool.mojostdlib/std/collections/: deque.mojo, dict.mojo, inline_array.mojo,
linked_list.mojo, list.mojo, optional.mojo, set.mojostdlib/std/iter/__init__.mojo, stdlib/std/itertools/itertools.mojostdlib/std/memory/: arc_pointer.mojo, owned_pointer.mojo, span.mojoConsolidated the reflection APIs in std.reflection behind a unified entry
point reflect[T]() returning a Reflected[T] handle. reflect is
auto-imported via the prelude, so it is available without an explicit
import. Methods on the handle replace the family of struct_field_* free
functions (dropping the struct_ prefix — only structs have fields) and
the get_type_name / get_base_type_name free functions:
struct Point:
var x: Int
var y: Float64
def main():
comptime r = reflect[Point]()
print(r.name()) # "Point"
print(r.field_count()) # 2
print(r.field_names()[0]) # x
comptime y_type = r.field_type["y"]() # Reflected[Float64]
print(y_type.name()) # "SIMD[DType.float64, 1]"
print(reflect[List[Int]]().base_name()) # "List"
var v: y_type.T = 3.14
Methods on Reflected[T]: name[qualified_builtins=], base_name,
is_struct, field_count, field_names, field_types,
field_index[name], field_type[name],
field_offset[name=]/[index=], and field_ref[idx](s). The
field_type[name]() method returns a Reflected[FieldT], so reflection
is fully composable.
The legacy free functions — struct_field_count, struct_field_names,
struct_field_types, struct_field_index_by_name,
struct_field_type_by_name, struct_field_ref, is_struct_type,
offset_of, get_type_name, get_base_type_name — and the
ReflectedType[T] wrapper are now @deprecated and delegate to the new
API. They will be removed in a future release.
Added struct_field_ref[idx, T](ref s) to std.reflection for accessing
struct fields by index without copying. The function returns a reference
with the same mutability as s and works with both concrete and generic
struct types, including parametric indices in comptime for loops. The
default implementations of Hashable, Equatable, and Writable now use
this library function instead of the __struct_field_ref magic.
The Boolable, Defaultable, and Writable traits no longer inherit from
ImplicitlyDestructible. Generic code that relied on receiving the
destructor bound transitively through these traits must now spell it out
explicitly, for example T: Writable & ImplicitlyDestructible.
The Variadic suite of low-level operation has been refactored and migrated
to being members of the TypeList and ParameterList types, making them more
ergonomic to work with and more accessible.
Atomic operations have moved to a dedicated std.atomic module. The
Consistency type has been renamed to Ordering and its MONOTONIC
member has been renamed to RELAXED to align with conventions used by
other languages. Update existing code as follows:
# Before
from std.os import Atomic
from std.os.atomic import Atomic, Consistency, fence
_ = atom.load[ordering=Consistency.MONOTONIC]()
# After
from std.atomic import Atomic, Ordering, fence
_ = atom.load[ordering=Ordering.RELAXED]()
Added Optional.destroy_with(destroy_func), which destroys an Optional[T]
in-place using a caller-provided destructor. This enables Optional to hold
element types that are not ImplicitlyDestructible (for example, types
marked @explicit_destroy), mirroring Variant.destroy_with. Both
Optional.destroy_with and Variant.destroy_with now accept closures that
capture local state in addition to plain function references. Note that
Variant.destroy_with callers must now pass the destroyed type explicitly
(for example, v^.destroy_with[Int](destroy_func)) since T can no longer
be inferred from the closure type.
assert_raises now catches custom Writable error types, not just Error.
Added UAX #29 grapheme cluster segmentation to String and StringSlice.
New APIs: graphemes() returns a GraphemeSliceIter that yields each
user-perceived "character" as a StringSlice, and count_graphemes() returns
the grapheme cluster count. This correctly handles combining marks, emoji ZWJ
sequences, flag emoji, Hangul syllables, and other multi-codepoint clusters.
StringSlice now supports slicing by grapheme cluster via the grapheme=
keyword argument, mirroring the existing byte= indexer. For example,
s[grapheme=0:3] returns a StringSlice covering the first three grapheme
clusters, and s[grapheme=i:i+1] extracts the i-th grapheme. Out-of-range
ends are clamped to the end of the string; negative indices are not supported.
Because grapheme boundaries are discovered by a forward scan, this operation
is O(n) in the byte length — prefer byte= slicing when you already have
byte offsets.
GraphemeSliceIter exposes a new remaining_byte_length() accessor that
reports the byte length of the iterator's remaining range in O(1). This
lets callers compute how many bytes the iterator has produced so far
without summing per-grapheme byte lengths, and is now used by
StringSlice[grapheme=...] for an ~1.4x speedup on ASCII-heavy inputs.
GraphemeSliceIter now supports reverse iteration. next_back() and
peek_back() return the last grapheme cluster in the remaining range, and
StringSlice.graphemes_reversed() / String.graphemes_reversed() return a
GraphemeSliceIter whose for-loop iteration walks clusters from end to
start. next() and next_back() can be interleaved on the same iterator.
Reverse iteration costs more per cluster than forward iteration because the
UAX #29 state machine is inherently forward-scanning: next_back() backs
up to a guaranteed grapheme boundary (the start of the string or a
Control/CR/LF codepoint) and rescans forward. The safe boundary is cached
across reverse calls — a forward next() invalidates it — so per-call cost
is dominated by forward-scan length: small in text containing line breaks
or whitespace, growing with the distance back to such a codepoint in long
runs without them.
Added grapheme-aware algorithms on String and StringSlice:
grapheme_indices() returns a GraphemeIndicesIter that yields
(byte_offset, grapheme) pairs, mirroring Rust's
str::grapheme_indices. Useful for text editors or UIs that need to
map cursor byte positions back to grapheme boundaries.nth_grapheme(n) returns the n-th grapheme cluster as an
Optional[StringSlice], or None when n is out of range.split_at_grapheme(n) returns Tuple[StringSlice, StringSlice]
holding the prefix [0, n) and suffix [n, count) of grapheme
clusters in a single pass, clamping n to the total count.count_graphemes() now takes a fast path over runs of printable ASCII
(U+0020..U+007E). Each such byte has GBP Other and two consecutive
safe-ASCII bytes always have a grapheme-cluster break between them
(GB999), so safe-ASCII runs can be counted at one grapheme per byte
without entering the UAX #29 state machine. On pure-ASCII text this is
roughly 10x faster (~0.38 ms vs. ~3.85 ms for 1 MB of English), and
~5-6x faster on ASCII-dominant mixed text (Spanish UN charter). Pure
non-ASCII text (Arabic, Russian, Chinese) is unchanged.
Variadics of types have been moved to the TypeList struct.
One can write operations such as:
comptime assert TypeList[Trait=AnyType, Int, String]().contains[Bool]
abort(message) now includes the call site location in its output. The
location is automatically captured and printed alongside the message. You can
also pass an explicit SourceLocation to override it:
abort("something went wrong")
# prints: ABORT: path/to/file.mojo:42:5: something went wrong
var loc = current_location()
abort("something went wrong", location=loc)
abort(message) now prints its message on Nvidia and AMDGPU, including
block and thread IDs. Previously, the message was silently suppressed on
these GPUs. On Apple GPU, the message is silently suppressed for now.
SourceLocation fields (line, col, file_name) are now private.
Use the new accessor methods line(), column(), and file_name() instead.
Fixed default alignment in TileTensor.load() and TileTensor.store() to
use the caller-specified width parameter instead of Self.element_size.
Added uninitialized memory read detection for float loads. When compiled
with -D MOJO_STDLIB_SIMD_UNINIT_CHECK=true, every float load is checked
against the debug allocator's poison pattern (the largest finite value of
the float type, e.g. FLT_MAX for Float32). A match triggers abort()
with a descriptive message. The non-NaN poison pattern lets nan-check
and uninit-read-check coexist (a NaN poison would be flagged by
nan-check as a legitimate NaN error in kernels that intentionally only
write active positions). When disabled (the default), zero runtime
overhead. For MAX pipelines, set
MODULAR_MAX_DEBUG_UNINITIALIZED_READ_CHECK=true to enable both the debug
allocator and the load-time checks automatically.
Expanded Apple Silicon GPU support. Apple Metal GPU is now a more capable Mojo target.
print() and _printf() now work on Apple Metal GPU. Output is chunked
through the Metal os_log path, with a Float32-only formatter that
matches Metal's hardware constraints. _printf() currently emits the
format string only (not interpolated arguments); |x| < 1e-7 is
truncated to 0.0 and there is no scientific notation.external_memory[]() (dynamic threadgroup memory) is now supported on
Apple Silicon. The compiler and runtime bridge CUDA-style extern shared
symbols to Metal's setThreadgroupMemoryLength:atIndex: model, so
existing GPU kernels using external_memory[]() work unchanged.apple_mma_load, apple_mma_store,
_mma_apple) in std.gpu.compute.arch.mma_apple enable hardware matrix
multiply-accumulate on Apple GPU.CompilationTarget.is_apple_m5() to std.sys for detecting Apple
M5 targets at compile time; is_apple_silicon() now includes M5 in its
check.metal4 features by default when the
toolchain supports them, automatically appending -metal4 to the arch
instead of requiring explicit m5-metal4 selection.release ordering is not supported on Metal. Apple
GPU targets now use monotonic (relaxed) atomic ordering by default.Float64/Float80/Float128) for Apple GPU
targets, since Metal supports only Float16 and Float32.Standard library types now use conditional conformances, replacing previous
_constrained_conforms_to checks:
Span: Writable, HashableTuple, Optional, Variant, and UnsafeMaybeUninit: RegisterPassableVariant: Copyable, ImplicitlyCopyableOptional: DevicePassable (conditional on element type)Tuple now conditionally conforms to Defaultable, so generic
T: Defaultable code can default-construct tuples when all element types are
Defaultable.
OwnedDLHandle.get_symbol() now returns Optional[UnsafePointer[...]]
instead of aborting when a symbol is not found. This allows callers to handle
missing symbols gracefully.
UnsafePointer is now non-null by design. See the
non-null pointer proposal
for the full design and migration timeline.
The default null constructor __init__(out self) and __bool__(self) method
are now deprecated, and UnsafePointer no longer conforms to Defaultable or
Boolable.
To migrate, express nullability explicitly with
Optional[UnsafePointer[...]], which has the same layout as UnsafePointer
(the null address is the None niche) so nullable pointers remain
zero-overhead and can be used across C-FFIs.
# Before: null default construction
var ptr = UnsafePointer[Int, origin]()
# After: express absence with Optional
var ptr: Optional[UnsafePointer[Int, origin]] = None
# Before: Bool-based null check
if ptr:
use(ptr[])
# After: check the Optional, then unwrap
if ptr:
use(ptr.value()[])
If you specifically need a non-null placeholder for a field that will be
populated later (for example, a buffer that is allocated on demand) use
UnsafePointer.unsafe_dangling(), which returns a well-aligned but dangling
pointer. Note that unsafe_dangling() is not a null sentinel: types that
lazily allocate must track initialization separately.
GPU primitive id accessors (thread_idx, block_idx, block_dim,
grid_dim, global_idx, lane_id, warp_id, cluster_dim,
cluster_idx, and block_id_in_cluster) have migrated from UInt to
Int.
This is part of a broader migration to standardize on the Int type for
all sizes and offsets in Mojo. As a related step in the same migration,
TensorCore.load_a() and TensorCore.load_b() now also take Int
arguments instead of UInt.
To provide a gradual migration path, explicitly typed *_uint aliases of
the seven non-cluster accessors are available temporarily:
| Accessor | Legacy UInt alias |
|---|---|
thread_idx | thread_idx_uint |
block_idx | block_idx_uint |
block_dim | block_dim_uint |
grid_dim | grid_dim_uint |
global_idx | global_idx_uint |
lane_id | lane_id_uint |
warp_id | warp_id_uint |
The three cluster accessors (cluster_dim, cluster_idx,
block_id_in_cluster) migrated directly without *_uint aliases, since
their usage was limited.
Code can preserve its prior UInt behavior by using a renaming import of
the *_uint alias:
- from std.gpu import thread_idx
+ from std.gpu import thread_idx_uint as thread_idx
The temporary *_int accessors that briefly existed during the phased
migration as a forward-compatibility aid have been removed; use the
unprefixed accessors (which now return Int by default). The *_uint
aliases will eventually be deprecated and removed as well.
Added IterableOwned trait to the iteration module. Types conforming to
IterableOwned implement __iter__(var self), which consumes the collection
and returns an iterator that owns the underlying elements.
List now conforms to IterableOwned.Optional now conforms to IterableOwned.Deque now conforms to IterableOwned.LinkedList now conforms to IterableOwned.Dict now conforms to IterableOwned.Set now conforms to IterableOwned.Counter now conforms to IterableOwned.InlineArray now conforms to IterableOwned.Span now conforms to IterableOwned (conditional on T: Copyable).
The owned iterator yields copies of elements by value.enumerate, zip, map, peekable, take_while,
drop_while, product, cycle, count, repeat) now conform to
IterableOwned.enumerate(), zip(), map(), peekable(),
take_while(), drop_while(), product(), and cycle() that consume the
input iterable.CStringSlice can no longer represent a null pointer. To represent
nullability use Optional[CStringSlice] which is guaranteed to have the same
size and layout as const char*, where NULL is the empty Optional.
external_call's return_type's requirements has been relaxed from
TrivialRegisterPassable to RegisterPassable.
Negative indexing on all stdlib collections has been removed to enable cheap CPU bounds checks by default:
ListSpanInlineArrayStringStringSliceLinkedListDequeIntTupleUsing a negative IntLiteral for indexing will now trigger a compile-time
error, for example:
/tmp/main.mojo:3:12: note: call expansion failed with parameter value(s): (..., ...)
print(x[-1])
^
constraint failed: negative indexing is not supported, use e.g. `x[len(x) - 1]` instead
Update any x[-1] to x[len(x) - 1], following the compiler errors to
your call sites as above.
This does not affect any MAX ops that support negative indexing.
Bounds checking is now on by default for all collections on CPU, and will show you the call site in your code where you triggered the out of bounds access:
def main():
var x = [1, 2, 3]
print(x[3])
At: /tmp/main.mojo:3:12: Assert Error: index 3 is out of bounds, valid range is 0 to 2
Bounds checking is still off by default for GPU to avoid performance penalties. To enable it for tests:
mojo build -D ASSERT=all main.mojo
To turn off all asserts, including CPU bounds checking:
mojo build -D ASSERT=none main.mojo
alloc[T](count, alignment) will now abort if the underlying allocation
failed.
Added Variadic.contains_value comptime alias to check whether a variadic
sequence contains a specific value at compile time.
ArcPointer now conditionally conforms to Hashable and Equatable when
its inner type T does. Both __eq__ and __hash__ delegate to the managed
value, matching C++ shared_ptr and Rust Arc semantics. This makes
ArcPointer usable as a Dict key or Set element with value-based
equality. Pointer identity is still available via the is operator.
Path now conforms to Comparable, enabling lexicographic ordering and use
with sort().
range() overloads that took differently-typed arguments or arguments that
were Intable/IntableRaising but not Indexer have been removed. Callers
should ensure they're passing consistent integral argument types when calling
range().
Consistency now has a default constructor that selects RELEASE ordering on
Apple GPU and SEQUENTIAL on all other targets. All Atomic methods and
fence use this platform-aware default instead of hard-coding SEQUENTIAL.
NDBuffer has been fully removed. Please migrate to TileTensor.
Added a generic __contains__ method to Span for any element type
conforming to Equatable, not just Scalar types.
Fixed blocked_product in tile_layout to zip block and tiler dimensions
per mode, matching the legacy blocked_product behavior.
Added Span-based overloads for enqueue_copy, enqueue_copy_from, and
enqueue_copy_to on DeviceContext, DeviceBuffer, and HostBuffer,
providing a safer alternative to raw UnsafePointer for host-device memory
transfers.
String.__len__() has been deprecated. Prefer to use String.byte_length()
or String.count_codepoints().
Added map() and and_then() methods to Optional. map() transforms
the contained value by applying a function, returning Optional[To].
and_then() chains operations that themselves return an Optional, enabling
flat-mapping over fallible computations.
var o = Optional[Int](42)
def closure(n: Int) {} -> String:
return String(n + 1)
var mapped: Optional[String] = o.map[To=String](closure)
print(mapped) # Optional("43")
Added std.memory.forget_deinit() to enable low-level code to skip the usual
requirement to run a destructor for a value. This function should be used
rarely, when building low-level abstractions.
CPU DeviceContext expansion. DeviceContext(api="cpu") is now usable
as a stream-ordered execution context for CPU work, paving the way for
NUMA-aware CPU dispatch.
DeviceContext.enqueue_cpu_function() and
DeviceContext.enqueue_cpu_range() for stream-ordered execution of host
functions on CPU DeviceContext instances. enqueue_cpu_function
enqueues a single host function; enqueue_cpu_range enqueues a parallel
range whose tasks run concurrently but are stream-ordered relative to
surrounding work. Argument passing is not yet supported.parallelize, parallelize_over_rows (in
std.algorithm.backend.cpu.parallelize), and the elementwise
overloads in std.algorithm.functional now accept an optional trailing
ctx: Optional[DeviceContext] = None. When supplied, the provided CPU
DeviceContext is forwarded to sync_parallelize; when omitted, the
previous behavior is preserved.parallelism_level() overload that takes a CPU DeviceContext
and returns the thread-pool size for that specific context, enabling
NUMA-specific introspection.Readable GPU kernel names in profilers. GPU kernels in the standard library and across MAX kernels (elementwise, GEMV, multistage matmul, attention, convolution, MoE, normalization, quantization, BMM, grouped matmul, SM100 matmul, AMD matmul, communication, and sampling) now expose human-readable names in profiler traces such as Nsight Systems, replacing previously mangled KGEN symbols.
tile_io module for TileTensor data movement. Added a tile_io
module providing TileTensor copier traits and copy utilities for moving
data between memory hierarchies (DRAM/SRAM). The module includes:
GenericToSharedAsyncTileCopier, which moves a TileTensor from
generic memory into shared memory via NVIDIA's cp.async. On AMD and
Apple GPUs the underlying async_copy falls back to synchronous
loads/stores.swizzle: Swizzle parameter on
GenericToSharedAsyncTileCopier, mirroring the swizzled write path in
LocalToSharedTileCopier.masked: Bool = False parameter on
GenericToSharedAsyncTileCopier. When enabled, out-of-bounds vectors
receive a zero-byte copy with zero-fill, matching
LayoutTensor.copy_from_async[is_masked=True, fill=Fill.ZERO].AsyncTileCopier trait abstracting copier conformance.TMA gather4 for sparse 2D tensor loads. Added a TMA gather4
operation on SM100 (Blackwell) for loading 4 non-contiguous rows from a 2D
tensor in a single TMA instruction, surfaced as the
cp_async_bulk_tensor_2d_gather4 intrinsic in std.gpu.memory and
integrated with TMATensorTile. The API supports:
tile_height (multiple of 4)
and tile_width, replacing the prior 4-row-per-call limit.row_width — previously restricted to the swizzle box width.
The API automatically computes the box width from the swizzle constraint
and supports non-divisible widths via TMA hardware zero-fill on the last
column group, so kernels no longer need to hand-code column-group loops.1D TMA instructions for SM90+ NVIDIA GPUs. Added 1D TMA (Tensor Memory
Accelerator) instruction support in std.gpu.memory. 1D TMA copies do not
require a pre-allocated tensormap object on the host, providing greater
flexibility than the existing 2D–5D TMA path. New functions:
cp_async_bulk_shared_cluster_global, cp_async_bulk_global_shared_cta,
cp_async_bulk_prefetch, and cp_async_bulk_reduce_global_shared_cta
(the 1D counterpart to cp_async_bulk_tensor_reduce_global_shared_cta,
which reduces floating-point values from shared memory into global memory;
ADD only).
TileTensor API extensions.
TileTensor.bitcast[target_dtype](), which returns a new
TileTensor viewing the same storage and layout under a different
element dtype, replacing the
TileTensor(x.ptr.bitcast[Scalar[T]](), x.layout) idiom.TileTensor.flat_load and TileTensor.flat_store as raw-flat
accessors that read and write the underlying storage at a linear offset,
bypassing the tensor's layout.TileTensor.tile() overload that takes the tile shape as a
runtime/parameter argument, complementing the existing tile APIs.TileTensor.load() and load_linear() now default invariant=True
for immutable tensors, enabling the compiler to use ldg for read-only
memory accesses.TileTensor, ManagedTensorSlice,
and crd2idx to catch out-of-range coordinate accesses at compile time.Layout library extensions.
coalesce function for TensorLayout, mirroring
the legacy Layout.coalesce algorithm (skip shape-1 dims and merge
contiguous dims).write_repr_to to Layout for writing a debug representation to
a Writer.vectorize and distribute now accept layouts with runtime dimensions.row_major now accepts coord-like arguments directly, no longer
requiring them to be wrapped in tuples.comptime assert rather than a
where clause.CoordLike.value() to return Scalar[Self.DTYPE] instead of
Int, providing a more expressive return type for layout coordinate
values.Coord, RowMajorLayout, and ColMajorLayout once again take their
parameters as variadic arguments, improving ergonomics when specifying
individual coords. Use *splat to pass an existing list.Several standard library APIs that previously took legacy closures now
have unified-closure overloads: parallelize and parallelize_over_rows
(in std.algorithm.backend.cpu.parallelize), bench.bencher,
DeviceContext.execution_time, and DeviceContext.enqueue_function (the
GPU enqueue path, renamed from the previous enqueue_closure).
GPU device APIs.
std.sys.info and std.gpu.host.info recognize B300 targets so kernels
can dispatch correctly on the Blackwell B300 architecture.DeviceStream.enqueue_host_func(func, user_data) exposing the
cuLaunchHostFunc primitive for Mojo kernels and custom ops. Takes a
thin def(OpaquePointer[MutAnyOrigin]) -> None callback and an opaque
user_data pointer. CUDA-only today; non-CUDA backends raise.DeviceContext initialization now runs an automatic GPU health check
that detects hardware throttling, uncorrectable ECC errors, and zombie
VRAM, and fails device creation with an actionable error message on
unhealthy GPUs. Added DeviceContext.run_healthcheck() to re-invoke the
check explicitly. Set MODULAR_DEVICE_CONTEXT_DISABLE_HEALTHCHECK=true
to disable.elementwise index computation and dispatch with a
use_32bit fast path, 4× unrolled grid-stride processing, warp-aligned
block sizes, and SM100+ single-tile routing.AMD GPU intrinsics.
ds_read_tr8_b64 AMD GPU intrinsic in std.gpu.intrinsics,
performing a 64-bit LDS transpose load of 8-bit elements via
llvm.amdgcn.ds.read.tr8.b64. Supported on AMD CDNA4+ GPUs.Scalar[dtype] overload of readfirstlane so callers no longer
need bitcast workarounds to broadcast non-Int32 scalar values across
an AMD GPU wavefront.AMDBufferResource.load_to_lds in std.gpu.intrinsics now lowers to
the .ptr. form of the AMDGPU buffer-load-to-LDS intrinsic, fixing a
strided-layout regression on MLA layouts where cache_depth != depth
and head_dim_offset != 0. A new async_copies: Bool = False parameter
opts in to attaching the amdgpu.AsyncCopies alias scope on the load,
enabling LLVM vmcnt relaxation.broadcast=True parameter to GPU warp_id() (and related id
accessors) so callers can avoid manual warp.broadcast(warp_id())
patterns.Math, debug, and stdlib APIs.
align_down and align_up now accept generic SIMD[dtype, width]
integer values, replacing the previous UInt-only overloads.FastDiv and mulhi to support 64-bit integer types, with
NVIDIA-specific llvm.nvvm.mulhi.ull/ll intrinsics and 128-bit
arithmetic on other targets.check_bounds for collections that asserts on out-of-range
indices and reports the user's call site instead of stdlib source.debug_assert now accepts a call_location parameter, allowing callers
to override the reported SourceLocation so assertion errors can point
to user code rather than stdlib internals.Atomic.compare_exchange so
success_ordering is listed before failure_ordering, matching the
convention used by C++, Rust, and other languages.InlineArray's storage constructor now uses
debug_assert[assert_mode="safe"] for the element-count check, so size
mismatches are caught by default instead of only with -D ASSERT=all.The Mojo debugger now shows a Variant variable's active type name and
value in LLDB — e.g. Int(42) or String("hello") — instead of exposing
raw _DefaultVariantStorage internals.
The Mojo debugger now displays scalar types (e.g. UInt8, Float32) as
plain values instead of ([0] = value), and elides internal _mlir_value
wrapper fields from struct display.
mojo format no longer supports the deprecated fn keyword, nor the
removed owned argument convention.
Comptime function calls now print more nicely in error messages and generated
documentation, not including VariadicList/VariadicPack and including
keyword argument labels when required.
LSP and REPL responsiveness.
dict.mojo)
is roughly 2× faster, using signature-only resolution for transitive
dependencies inside docstring code blocks.mojo CLI and toolchain.
mojo --version now prints a semantic Mojo version (for example,
1.0.0...) instead of an internal build identifier, and the same
version is used wherever the compiler performs version checks.mojo build --print-supported-targets now lists registered targets
sorted alphabetically, with a graceful empty-list message.--target-triple without --target-cpu and the host and target
architectures differ.llvm-symbolizer
instead of atos, so stack traces report the full inlined call chain
through user functions.mojo doc and docstring validation.
mojo doc now preserves parameterized type names (for example
List[K], Optional[V], UnsafePointer[Scalar[dtype]]) in the API doc
JSON "type" fields, instead of emitting only the bare base name.mojo doc now emits a diagnostic when a public Mojo module has no
module-level docstring and -mojo-diagnose-missing-doc-strings is
active. Private modules and modules nested inside private packages are
exempt.// in a parameter list) to be documented; documenting them
remains valid.! and ? as valid sentence-ending
punctuation for summaries, section bodies, and argument descriptions.def ... raises functions now require a Raises: docstring section
like any other raising function, and the isDef field has been removed
from mojo doc JSON output.Debugger UX.
Optional[T] variables as None or
Some(value) in LLDB instead of exposing raw _DefaultVariantStorage
internals.UnsafePointer[T] values in
LLDB for all pointed-to types, including signed integers (no longer
rendered as huge unsigned values), Bool (True/False), and floats.StringSlice, StaticString, and their
underlying Span[Byte] values as quoted strings in LLDB.-O0, trivially destructible types (Int, Float, Bool, SIMD,
etc.) now remain visible in the debugger through the end of their
lexical scope instead of disappearing at the ASAP destruction point.mojo format (mblack) now correctly parses the new unified-closure
syntax including raises {captures} effect ordering, and no longer
inserts a spurious space between ^ and the operand in var^ captures.
Mojo package files (.mojopkg) now use format version 2 with
zstd-compressed MLIR bytecode, significantly reducing package, wheel, and
Docker image sizes.
Added a --mojo-version flag to mojo-lsp-server for verifying the Mojo
version that the LSP is using.
Removed the legacy MOJO_ENABLE_STACK_TRACE_ON_ERROR and
MOJO_ENABLE_STACK_TRACE_ON_CRASH environment variables. Instead, set the
MODULAR_DEBUG environment variable to stack_trace_on_error to enable
generation of stack traces when a Mojo program raises an error.
The escaping function effect is no longer supported. Migrate
def(...) escaping -> T closures to use an explicit capture list {...} (see
the
closure refactor entry under Language enhancements).
The deprecated @doc_private decorator has been removed. Use @doc_hidden
instead.
Removed the store_release, store_relaxed, load_acquire, and
load_relaxed helpers from std.gpu.intrinsics. Use
Atomic[dtype, scope=...].store and
Atomic[dtype, scope=...].load with
the desired Ordering instead:
# Before
from std.gpu.intrinsics import store_release, load_acquire
store_release[scope=Scope.GPU](ptr, value)
var v = load_acquire[scope=Scope.GPU](ptr)
# After
from std.atomic import Atomic, Ordering
Atomic[dtype, scope="device"].store[ordering=Ordering.RELEASE](ptr, value)
var v = Atomic[dtype, scope="device"].load[ordering=Ordering.ACQUIRE](ptr)
Several constructs deprecated in 26.2 are no longer accepted:
@register_passable and @register_passable("trivial") decorators
are no longer supported. Conform to the RegisterPassable and
TrivialRegisterPassable traits instead. Use of either decorator now
produces a hard error pointing to the trait equivalent.__moveinit__ and __copyinit__ method names are no longer
auto-rewritten to the unified __init__ form. Rename these methods to
__init__ with keyword-only take: Self and copy: Self arguments,
respectively, as introduced by
init unification in 26.2.
Existing legacy spellings now fail to compile with errors such as
no matching function in initialization rather than being silently
rewritten.API removals beyond the deprecation removals already noted:
param_env.mojo module. Use defines.mojo instead.LinkedList.__getitem__. Indexing a LinkedList is O(n), and
exposing __getitem__ encouraged accidentally quadratic code; iterate
the list instead.UIntSized trait and its prelude re-export.pdl_level parameter from elementwise, reduction, and
reducescatter kernel APIs. PDL usage is now an internal compile-time
default.Fixed math.sqrt on Float64 on NVIDIA GPU producing a cryptic
could not find LLVM intrinsic: "llvm.nvvm.sqrt.approx.d" failure at LLVM
IR translation time. math.sqrt now rejects Float64 on NVIDIA GPU at
compile time with the message DType.float64 isn't supported for approx sqrt on NVIDIA GPU. The existing math.sin and math.cos constraint
messages were also sharpened to name the op (DType.float64 isn't supported for sin/cos on NVIDIA GPU).
(Issue #6434)
Fixed pack inference failing with could not infer type of parameter pack ... given value with unresolved type when passing list, dict, set, or slice
literals to a *Ts-bound variadic pack parameter (e.g.
def foo[*Ts: Iterable](*args: *Ts)). Pack inference now applies the same
default-type fallback that single-argument trait-bound parameters already
use, so foo([1, 2, 3], [4, 5, 6]) resolves each literal to its default
type (e.g. List[Int]) before binding the pack.
Fixed mojo aborting at startup with std::filesystem::filesystem_error
when $HOME is not traversable by the running UID (common in containerized
CI where the image's build-time UID differs from the runtime UID). The
config search now treats permission errors as "not found" and falls through
to the next candidate.
(Issue #6412)
mojo run and mojo debug now honor -Xlinker flags by loading the
referenced shared libraries into the in-process JIT. Previously the flags
were dropped (with a -Xlinker argument unused warning), leaving programs
that called into external shared libraries via external_call unable to
resolve those symbols at runtime (so mojo build worked but mojo run did
not). The supported forms mirror what the system linker accepts: -Xlinker -L<dir>, -Xlinker -l<name>, -Xlinker -rpath <dir>, and -Xlinker <absolute-path-to-shared-library>. Flags that have no meaning under JIT
are reported as a warning and ignored.
(Issue #6155)
Fixed libpython auto-discovery failing for Python 3.14 free-threaded builds.
The discovery script constructed the library filename without the ABI flags
suffix (e.g. looked for libpython3.14.dylib instead of
libpython3.14t.dylib).
(Issue #6366)
Fixed RTLD.LOCAL having the wrong value on Linux. It was set to 4
(RTLD_NOLOAD) instead of 0, causing dlopen with RTLD.NOW | RTLD.LOCAL
to fail. (Issue #6410)
Fixed mojo format crashing after upgrading Mojo versions due to a stale
grammar cache. (Issue #6144)
Fixed atof producing incorrect results for floats near the
normal/subnormal boundary (e.g., Float64("4.4501363245856945e-308")
returned half the correct value).
(#6196)
Issue #5872: Fixed a
compiler crash ("'get_type_name' requires a concrete type") when using
default Writable, Equatable, or Hashable implementations on structs
with MLIR-type fields (e.g. __mlir_type.index). The compiler now correctly
reports that the field does not implement the required trait.
Fixed Atomic.store silently dropping the requested scope. The previous
implementation lowered to atomicrmw xchg without forwarding syncscope,
so Atomic[..., scope="device"].store(...) was emitting a system-scope
store on NVPTX (extra L2/NVLink fences) and an over-synchronized store on
AMDGPU. Atomic.store now lowers via pop.store atomic syncscope(...),
emitting st.release.<scope> on NVPTX and a properly-scoped LLVM atomic
store on AMDGPU. The Mojo API surface is unchanged.
Fixed Process.run() not inheriting the parent's environment variables.
Child processes spawned via Process.run() now correctly receive the
parent's environment.
Fixed \xhh and \ooo escape sequences in string literals being
interpreted as raw bytes instead of Unicode code points, which produced
malformed UTF-8 for values >= 0x80. The escapes now match Python str
semantics (and the existing \u/\U handling): "\x85" encodes U+0085
(NEL) as two UTF-8 bytes and ord("\x85") returns 133 instead of 5.
Code that relied on \xhh to emit a single raw byte for non-ASCII values
must construct the bytes explicitly (for example via a List[Byte]
literal).
(Issue #2842)
Fixed incorrect data layout for MI250X AMDGPU architectures.
(Issue #6451
Fixed Apple Silicon target detection on macOS 26 producing unrecognized
arch strings like metal:2-metal4 when the installed Xcode could not
compile Metal 4.0; the -metal4 suffix is now applied only when the
toolchain supports it.
Fixed UnsafePointer.gather, UnsafePointer.scatter, and strided_load
silently reading zero on Apple GPU. The per-lane fallback reconstructed
pointers via unsafe_from_address=Int(addr), yielding a generic-address-space
pointer the Apple AIR backend could not resolve. The fallback now uses typed
pointer arithmetic on Apple GPU; NVIDIA, AMD, and CPU paths are unchanged.
Fixed rotate_left and rotate_right intrinsics failing to lower on
Apple GPU. Both now lower correctly to the Apple AIR backend.
Fixed TileTensor.write_to() only handling 2D static-shape tensors; 1D,
3D+, nested-layout, and dynamic-shape tensors now print correctly via a
generic elementwise fallback, and all ranks use a bracket-delimited,
comma-separated format.
Fixed incorrect alignment in TileTensor.__getitem__.
Fixed TileTensor SIMD loads/stores on CPU to use alignment=1,
preventing segfaults when underlying data is not naturally aligned. GPU
still uses aligned access where the layout guarantees alignment.
Fixed complement() in tile_layout returning a static shape of 0
when given UNKNOWN_VALUE as the size; it now propagates UNKNOWN_VALUE
so downstream layout algebra falls back to runtime dimensions, restoring
correct bounds checks for LayoutTensor.flatten().vectorize[N]().
Fixed idx2crd returning incorrect coordinates for nested layouts.
Fixed mojo --version printing the MAX version instead of the Mojo
compiler version.
Fixed comptime and/or expressions to accept any Boolable operands,
matching runtime behavior. This also enables mixed-type expressions like
comptime if some_Bool and some_Optional.
Fixed several codegen correctness issues affecting valid Mojo programs:
an SRoA miscompile that incorrectly promoted arrays accessed via dynamic
offsets through a constant GEP; a use-after-free where destructors of
live owned values were inserted before, rather than after, a
lit.ref.store into a ref with #lit.any.origin; silent memory
corruption when calling abi("C") functions that returned structs via
sret; and bogus existing function with conflicting attributes errors
when calling the same external function more than once with an
sret/byval ABI.
Fixed several mojo-lsp-server crashes affecting REPL/notebook contexts,
parameter-pack-related diagnostics, files importing from .mojopkg, and
files using stateless closures. The LSP also no longer mistakes REPL
buffer identifiers (which contain a .mojo extension) for relative
module imports.
Fixed several debugger display issues: variables after their ASAP
destruction point at -O0 now correctly show "not available" instead of
stale values; unsigned integers (UInt, UInt8, etc.) display with
correct unsigned semantics; ref loop variables show index instead of
pointer<index>; String fields typed as Scalar[T] and Tuple values
display correctly.
Fixed two mojo format (mblack) issues: it no longer loses the t
prefix when splitting long t-string literals across lines, and no longer
inserts a stray space between * and a complex operand in variadic pack
unpacking annotations.
Fixed BitSet.set_all and BitSet.toggle_all writing ~0 to every
underlying 64-bit word, including bits beyond the logical size when
size was not a multiple of 64. Those stray high bits were counted by
__len__, producing incorrect population counts; the methods now mask
off the unused high bits.
Fixed syncwarp on AMD GPUs, which was previously implemented as a
no-op. It now lowers to llvm.amdgcn.wave.barrier, providing the
control-flow synchronization required to correctly sequence shared-memory
writes followed by reads across lanes.
Fixed isnan, isinf, and isfinite failing during LLVM lowering for
float8_e3m4 and float4_e2m1fn. float4_e2m1fn (no NaN/Inf encodings)
folds to constant branches; float8_e3m4 casts through bfloat16 to
reuse the existing llvm.is.fpclass path.
Compilation targets docs instructs how to inspect your current platform, select a target configuration, and generate code for that target. Use it to build for your own system or target other CPUs, operating systems, and accelerators.
Mojo language reference covers lexical elements, expressions, statements, numeric types, struct declarations, trait declarations.
Functions reference page improves discoverability of new function features.
Split operators manual into separate pages; refreshed coverage and added tutorial, operator tests, and new reference page.
Negative examples and errors added to reference pages highlight sharp edges of the language.
MLIR reference page introduces inline MLIR to developers in Mojo code.
Adds docs for non-nullable pointers and provides sample code showing
how to use Optional with UnsafePointer.
Added type refinement based on compile time assumptions, enabling Mojo to
narrow types from where clauses, comptime if statements, and
comptime assert statements. Refinements in a scope are driven by
conforms_to() expressions.
Before:
def __contains__(self, value: Self.T) -> Bool where conforms_to(Self.T, Equatable):
for item in self:
if trait_downcast[Equatable](item) == trait_downcast[Equatable](value):
return True
return False
After:
def __contains__(self, value: Self.T) -> Bool where conforms_to(Self.T, Equatable):
for item in self:
if item == value:
return True
return False
Improved diagnostics for onboarding-priority parser errors in Mojo for clarity and UX.
Migrated monorepo from fn to using def for function declaration.
Warned on use of fn and will deprecate fn in the next release.
Updated signature error diagnostics and added related tests.
Mojo now uses NoneType instead of an empty tuple to mark constructor
using literals.
The ternary if/else expression now coerces each element to its contextual
type when it is obvious. For example, this works instead of producing an
error about incompatible metatypes:
comptime some_type: Movable = Int if cond else String
Unified closures now accept default capturing conventions when there are explicit captures already.
def captures_with_default_convention():
var a, b, c, d = ("a", "b", "c", "d")
def my_fn() unified {mut a, b, c^, read}:
# capture:
# `a` by mut reference
# `b` by immut reference
# `c` by moving
# `d` by immut reference (the default 'read' convention)
use(a, b, c, d)
Added abi("C") as a function effect for declaring C calling convention on
function definitions and function pointer types. Functions marked with
abi("C") use the platform C ABI (System V x86-64 / ARM64 AAPCS) for
struct arguments and return values, enabling safe interop with C libraries:
# C-ABI function definition (safe as a callback into C code)
def add(a: Int32, b: Int32) abi("C") -> Int32:
return a + b
# C-ABI function pointer type (safe for use with DLHandle.get_function)
var f = handle.get_function[def(Float64) abi("C") -> Float64]("sqrt")
DLHandle.get_function[] now enforces that the type parameter carries
abi("C"), preventing silent ABI mismatches when loading C symbols.
String literals now support \uXXXX and \UXXXXXXXX unicode escape
sequences, matching Python. The resulting code point is stored as UTF-8.
Invalid code points and surrogates are rejected at parse time.
Added support for conditional RegisterPassable conformance.
Variadic lists and packs can be forwarded through runtime calls with *pack
when the callee takes a compatible variadic list/pack.
def callee[*Ts: Writable](*args: *Ts):
comptime for i in range(args.__len__()):
print(args[i])
def forwarder[*Ts: Writable](*args: *Ts):
callee(*args)
forwarder(1, "hello", 3.14) # prints each value on a separate line
Heterogenous variadic packs can now be specified with a SomeType helper
function. These two are equivalent:
def foo[*arg_types: Copyable](*args: *arg_types) -> Int: ...
def foo(*args: *SomeTypeList[Copyable]) -> Int: ...
T-strings can now be used in comptime assert messages:
def foo[i: Int]():
comptime assert i > 5, t"expected i > 5, got {i}"
Variadic parameters lists are now passed instead of ParameterList and
TypeList instead of !kgen.param_list. This makes it much more ergonomic to
work with these types, e.g. simple logic just works:
def callee[*values: Int]():
var v = 0
for i in range(len(values)):
v += values[i]
for elt in values:
v += elt
Similarly, the ParameterList/TypeList structs have other methods for
transforming the value list. As such, a variety of values from the Variadic
struct have started moving over to being members of these types.
All Mojo functions now has a unique "function literal type". In practice, it means that:
# type_of(foo) != type_of(bar)
def foo(): pass
def bar(): pass
Mojo now warns on uses of the legacy fn keyword. Please move to def as
this will upgrade to an error in the future.
Import statements of the form from pkg import ... no longer make pkg
available to the module.
Removed explicit trait_downcast/trait_downcast_var across the standard
library sources, now that Mojo applies type refinement from comptime
assumptions. Public APIs are unchanged. Updated files:
stdlib/std/builtin/: _stubs.mojo, bool.mojostdlib/std/collections/: deque.mojo, dict.mojo, inline_array.mojo,
linked_list.mojo, list.mojo, optional.mojo, set.mojostdlib/std/iter/__init__.mojo, stdlib/std/itertools/itertools.mojostdlib/std/memory/: arc_pointer.mojo, owned_pointer.mojo, span.mojoConsolidated the reflection APIs in std.reflection behind a unified entry
point reflect[T]() returning a Reflected[T] handle. reflect is
auto-imported via the prelude, so it is available without an explicit
import. Methods on the handle replace the family of struct_field_* free
functions (dropping the struct_ prefix — only structs have fields) and
the get_type_name / get_base_type_name free functions:
struct Point:
var x: Int
var y: Float64
def main():
comptime r = reflect[Point]()
print(r.name()) # "Point"
print(r.field_count()) # 2
print(r.field_names()[0]) # x
comptime y_type = r.field_type["y"]() # Reflected[Float64]
print(y_type.name()) # "SIMD[DType.float64, 1]"
print(reflect[List[Int]]().base_name()) # "List"
var v: y_type.T = 3.14
Methods on Reflected[T]: name[qualified_builtins=], base_name,
is_struct, field_count, field_names, field_types,
field_index[name], field_type[name],
field_offset[name=]/[index=], and field_ref[idx](s). The
field_type[name]() method returns a Reflected[FieldT], so reflection
is fully composable.
The legacy free functions — struct_field_count, struct_field_names,
struct_field_types, struct_field_index_by_name,
struct_field_type_by_name, struct_field_ref, is_struct_type,
offset_of, get_type_name, get_base_type_name — and the
ReflectedType[T] wrapper are now @deprecated and delegate to the new
API. They will be removed in a future release.
Added struct_field_ref[idx, T](ref s) to std.reflection for accessing
struct fields by index without copying. The function returns a reference
with the same mutability as s and works with both concrete and generic
struct types, including parametric indices in comptime for loops. The
default implementations of Hashable, Equatable, and Writable now use
this library function instead of the __struct_field_ref magic.
The Boolable, Defaultable, and Writable traits no longer inherit from
ImplicitlyDestructible. Generic code that relied on receiving the
destructor bound transitively through these traits must now spell it out
explicitly, for example T: Writable & ImplicitlyDestructible.
The Variadic suite of low-level operation has been refactored and migrated
to being members of the TypeList and ParameterList types, making them more
ergonomic to work with and more accessible.
Atomic operations have moved to a dedicated std.atomic module. The
Consistency type has been renamed to Ordering and its MONOTONIC
member has been renamed to RELAXED to align with conventions used by
other languages. Update existing code as follows:
# Before
from std.os import Atomic
from std.os.atomic import Atomic, Consistency, fence
_ = atom.load[ordering=Consistency.MONOTONIC]()
# After
from std.atomic import Atomic, Ordering, fence
_ = atom.load[ordering=Ordering.RELAXED]()
assert_raises now catches custom Writable error types, not just Error.
Added UAX #29 grapheme cluster segmentation to String and StringSlice.
New APIs: graphemes() returns a GraphemeSliceIter that yields each
user-perceived "character" as a StringSlice, and count_graphemes() returns
the grapheme cluster count. This correctly handles combining marks, emoji ZWJ
sequences, flag emoji, Hangul syllables, and other multi-codepoint clusters.
StringSlice now supports slicing by grapheme cluster via the grapheme=
keyword argument, mirroring the existing byte= indexer. For example,
s[grapheme=0:3] returns a StringSlice covering the first three grapheme
clusters, and s[grapheme=i:i+1] extracts the i-th grapheme. Out-of-range
ends are clamped to the end of the string; negative indices are not supported.
Because grapheme boundaries are discovered by a forward scan, this operation
is O(n) in the byte length — prefer byte= slicing when you already have
byte offsets.
GraphemeSliceIter now supports reverse iteration. next_back() and
peek_back() return the last grapheme cluster in the remaining range, and
StringSlice.graphemes_reversed() / String.graphemes_reversed() return a
GraphemeSliceIter whose for-loop iteration walks clusters from end to
start. next() and next_back() can be interleaved on the same iterator.
Reverse iteration costs more per cluster than forward iteration because the
UAX #29 state machine is inherently forward-scanning: next_back() backs
up to a guaranteed grapheme boundary (the start of the string or a
Control/CR/LF codepoint) and rescans forward. The safe boundary is cached
across reverse calls — a forward next() invalidates it — so per-call cost
is dominated by forward-scan length: small in text containing line breaks
or whitespace, growing with the distance back to such a codepoint in long
runs without them.
Added grapheme-aware algorithms on String and StringSlice:
grapheme_indices() returns a GraphemeIndicesIter that yields
(byte_offset, grapheme) pairs, mirroring Rust's
str::grapheme_indices. Useful for text editors or UIs that need to
map cursor byte positions back to grapheme boundaries.nth_grapheme(n) returns the n-th grapheme cluster as an
Optional[StringSlice], or None when n is out of range.split_at_grapheme(n) returns Tuple[StringSlice, StringSlice]
holding the prefix [0, n) and suffix [n, count) of grapheme
clusters in a single pass, clamping n to the total count.count_graphemes() now takes a fast path over runs of printable ASCII
(U+0020..U+007E). Each such byte has GBP Other and two consecutive
safe-ASCII bytes always have a grapheme-cluster break between them
(GB999), so safe-ASCII runs can be counted at one grapheme per byte
without entering the UAX #29 state machine. On pure-ASCII text this is
roughly 10x faster (~0.38 ms vs. ~3.85 ms for 1 MB of English), and
~5-6x faster on ASCII-dominant mixed text (Spanish UN charter). Pure
non-ASCII text (Arabic, Russian, Chinese) is unchanged.
Variadics of types have been moved to the TypeList struct.
One can write operations such as:
comptime assert TypeList[Trait=AnyType, Int, String]().contains[Bool]
abort(message) now includes the call site location in its output. The
location is automatically captured and printed alongside the message. You can
also pass an explicit SourceLocation to override it:
abort("something went wrong")
# prints: ABORT: path/to/file.mojo:42:5: something went wrong
var loc = current_location()
abort("something went wrong", location=loc)
abort(message) now prints its message on Nvidia and AMDGPU, including
block and thread IDs. Previously, the message was silently suppressed on
these GPUs. On Apple GPU, the message is silently suppressed for now.
SourceLocation fields (line, col, file_name) are now private.
Use the new accessor methods line(), column(), and file_name() instead.
Fixed default alignment in TileTensor.load() and TileTensor.store() to
use the caller-specified width parameter instead of Self.element_size.
Added uninitialized memory read detection for float loads. When compiled
with -D MOJO_STDLIB_SIMD_UNINIT_CHECK=true, every float load is checked
against the debug allocator's poison patterns (0xFF host fill and canonical
qNaN device fill). A match triggers abort() with a descriptive message.
When disabled (the default), zero runtime overhead. For MAX pipelines, set
MODULAR_MAX_DEBUG_UNINITIALIZED_READ_CHECK=true (or the
max-debug.uninitialized-read-check config key, or
InferenceSession.debug.uninitialized_read_check = True) to enable both the
debug allocator and the load-time checks automatically.
Added CompilationTarget.is_apple_m5() to std.sys for detecting Apple M5
targets at compile time. is_apple_silicon() now includes M5 in its check.
Added Apple M5 MMA intrinsics (apple_mma_load, apple_mma_store,
_mma_apple) in std.gpu.compute.arch.mma_apple, enabling hardware matrix
multiply-accumulate on Apple GPU.
Standard library types now use conditional conformances, replacing previous
_constrained_conforms_to checks:
Span: Writable, HashableTuple, Optional, Variant, and UnsafeMaybeUninit: RegisterPassableVariant: Copyable, ImplicitlyCopyableTuple now conditionally conforms to Defaultable, so generic
T: Defaultable code can default-construct tuples when all element types are
Defaultable.
OwnedDLHandle.get_symbol() now returns Optional[UnsafePointer[...]]
instead of aborting when a symbol is not found. This allows callers to handle
missing symbols gracefully.
UnsafePointer is now non-null by design. See the
non-null pointer proposal
for the full design and migration timeline.
The default null constructor __init__(out self) and __bool__(self) method
are now deprecated, and UnsafePointer no longer conforms to Defaultable or
Boolable.
To migrate, express nullability explicitly with
Optional[UnsafePointer[...]], which has the same layout as UnsafePointer
(the null address is the None niche) so nullable pointers remain
zero-overhead and can be used across C-FFIs.
# Before: null default construction
var ptr = UnsafePointer[Int, origin]()
# After: express absence with Optional
var ptr: Optional[UnsafePointer[Int, origin]] = None
# Before: Bool-based null check
if ptr:
use(ptr[])
# After: check the Optional, then unwrap
if ptr:
use(ptr.value()[])
If you specifically need a non-null placeholder for a field that will be
populated later (for example, a buffer that is allocated on demand) use
UnsafePointer.unsafe_dangling(), which returns a well-aligned but dangling
pointer. Note that unsafe_dangling() is not a null sentinel: types that
lazily allocate must track initialization separately.
GPU primitive id accessors (e.g. thread_idx) have migrated from UInt to
Int.
This is part of a broader migration to standardize on the Int type for all
sizes and offsets in Mojo.
To provide a gradual migration path, explicitly typed aliases are available temporarily.
| Base | UInt Accessor | Int Accessor |
|---|---|---|
thread_idx | thread_idx_uint | thread_idx_int |
thread_dim | thread_dim_uint | thread_dim_int |
block_dim | block_dim_uint | block_dim_int |
grid_dim | grid_dim_uint | grid_dim_int |
global_idx | global_idx_uint | global_idx_int |
lane_id | lane_id_uint | lane_id_int |
warp_id | warp_id_uint | warp_id_int |
Code can preserve its prior behavior by using a renaming import of the
thread_idx_uint alias:
- from std.gpu import thread_idx
+ from std.gpu import thread_idx_uint as thread_idx
Note that thread_idx_uint and the other _*uint aliases will eventually
be deprecated and removed as well.
After a temporary deprecation acting as a "speed bump" in the 2026-03-29
nightly release, thread_idx etc. have changed from UInt to Int.
Code built with a version where thread_idx is still UInt, can proactively
migrate to the eventual Int behavior using the thread_idx_int alias:
- from std.gpu import thread_idx
+ from std.gpu import thread_idx_int as thread_idx
# ... update file to reflect change from `UInt` to `Int` ...
Added IterableOwned trait to the iteration module. Types conforming to
IterableOwned implement __iter__(var self), which consumes the collection
and returns an iterator that owns the underlying elements.
List now conforms to IterableOwned.Optional now conforms to IterableOwned.Deque now conforms to IterableOwned.LinkedList now conforms to IterableOwned.Dict now conforms to IterableOwned.Set now conforms to IterableOwned.Counter now conforms to IterableOwned.InlineArray now conforms to IterableOwned.Span now conforms to IterableOwned (conditional on T: Copyable).
The owned iterator yields copies of elements by value.enumerate, zip, map, peekable, take_while,
drop_while, product, cycle, count, repeat) now conform to
IterableOwned.enumerate(), zip(), map(), peekable(),
take_while(), drop_while(), product(), and cycle() that consume the
input iterable.CStringSlice can no longer represent a null pointer. To represent
nullability use Optional[CStringSlice] which is guaranteed to have the same
size and layout as const char*, where NULL is the empty Optional.
external_call's return_type's requirements has been relaxed from
TrivialRegisterPassable to RegisterPassable.
Negative indexing on all stdlib collections has been removed to enable cheap CPU bounds checks by default:
ListSpanInlineArrayStringStringSliceLinkedListDequeIntTupleUsing a negative IntLiteral for indexing will now trigger a compile-time
error, for example:
/tmp/main.mojo:3:12: note: call expansion failed with parameter value(s): (..., ...)
print(x[-1])
^
constraint failed: negative indexing is not supported, use e.g. `x[len(x) - 1]` instead
Update any x[-1] to x[len(x) - 1], following the compiler errors to
your call sites as above.
This does not affect any MAX ops that support negative indexing.
Bounds checking is now on by default for all collections on CPU, and will show you the call site in your code where you triggered the out of bounds access:
def main():
var x = [1, 2, 3]
print(x[3])
At: /tmp/main.mojo:3:12: Assert Error: index 3 is out of bounds, valid range is 0 to 2
Bounds checking is still off by default for GPU to avoid performance penalties. To enable it for tests:
mojo build -D ASSERT=all main.mojo
To turn off all asserts, including CPU bounds checking:
mojo build -D ASSERT=none main.mojo
alloc[T](count, alignment) will now abort if the underlying allocation
failed.
Added Variadic.contains_value comptime alias to check whether a variadic
sequence contains a specific value at compile time.
ArcPointer now conditionally conforms to Hashable and Equatable when
its inner type T does. Both __eq__ and __hash__ delegate to the managed
value, matching C++ shared_ptr and Rust Arc semantics. This makes
ArcPointer usable as a Dict key or Set element with value-based
equality. Pointer identity is still available via the is operator.
Path now conforms to Comparable, enabling lexicographic ordering and use
with sort().
range() overloads that took differently-typed arguments or arguments that
were Intable/IntableRaising but not Indexer have been removed. Callers
should ensure they're passing consistent integral argument types when calling
range().
Consistency now has a default constructor that selects RELEASE ordering on
Apple GPU and SEQUENTIAL on all other targets. All Atomic methods and
fence use this platform-aware default instead of hard-coding SEQUENTIAL.
NDBuffer has been fully removed. Please migrate to TileTensor.
Added a generic __contains__ method to Span for any element type
conforming to Equatable, not just Scalar types.
Fixed blocked_product in tile_layout to zip block and tiler dimensions
per mode, matching the legacy blocked_product behavior.
Added Span-based overloads for enqueue_copy, enqueue_copy_from, and
enqueue_copy_to on DeviceContext, DeviceBuffer, and HostBuffer,
providing a safer alternative to raw UnsafePointer for host-device memory
transfers.
String.__len__() has been deprecated. Prefer to use String.byte_length()
or String.count_codepoints().
Added map() and and_then() methods to Optional. map() transforms
the contained value by applying a function, returning Optional[To].
and_then() chains operations that themselves return an Optional, enabling
flat-mapping over fallible computations.
var o = Optional[Int](42)
def closure(n: Int) unified {} -> String:
return String(n + 1)
var mapped: Optional[String] = o.map[To=String](closure)
print(mapped) # Optional("43")
Added std.memory.forget_deinit() to enable low-level code to skip the usual
requirement to run a destructor for a value. This function should be used
rarely, when building low-level abstractions.
parallelize, parallelize_over_rows (in
std.algorithm.backend.cpu.parallelize) and the elementwise overloads in
std.algorithm.functional now accept an optional trailing
ctx: Optional[DeviceContext] = None parameter. When supplied, the provided
CPU DeviceContext is forwarded to sync_parallelize so that parallel work
runs on that context; when omitted, the previous behavior is preserved. This
is a step toward running CPU ops on specific NUMA nodes.
The Mojo debugger now shows a Variant variable's active type name and
value in LLDB — e.g. Int(42) or String("hello") — instead of exposing
raw _DefaultVariantStorage internals.
The Mojo debugger now displays scalar types (e.g. UInt8, Float32) as
plain values instead of ([0] = value), and elides internal _mlir_value
wrapper fields from struct display.
mojo format no longer supports the deprecated fn keyword, nor the
removed owned argument convention.
Comptime function calls now print more nicely in error messages and generated
documentation, not including VariadicList/VariadicPack and including
keyword argument labels when required.
The escaping function effect is no longer supported. Migrate
def(...) escaping -> T closures to unified closures.
The deprecated @doc_private decorator has been removed. Use @doc_hidden
instead.
Removed the store_release, store_relaxed, load_acquire, and
load_relaxed helpers from std.gpu.intrinsics. Use
Atomic[dtype, scope=...].store and
Atomic[dtype, scope=...].load with
the desired Ordering instead:
# Before
from std.gpu.intrinsics import store_release, load_acquire
store_release[scope=Scope.GPU](ptr, value)
var v = load_acquire[scope=Scope.GPU](ptr)
# After
from std.atomic import Atomic, Ordering
Atomic[dtype, scope="device"].store[ordering=Ordering.RELEASE](ptr, value)
var v = Atomic[dtype, scope="device"].load[ordering=Ordering.ACQUIRE](ptr)
Fixed math.sqrt on Float64 on NVIDIA GPU producing a cryptic
could not find LLVM intrinsic: "llvm.nvvm.sqrt.approx.d" failure at LLVM
IR translation time. math.sqrt now rejects Float64 on NVIDIA GPU at
compile time with the message DType.float64 isn't supported for approx sqrt on NVIDIA GPU. The existing math.sin and math.cos constraint
messages were also sharpened to name the op (DType.float64 isn't supported for sin/cos on NVIDIA GPU).
(Issue #6434)
Fixed pack inference failing with could not infer type of parameter pack ... given value with unresolved type when passing list, dict, set, or slice
literals to a *Ts-bound variadic pack parameter (e.g.
def foo[*Ts: Iterable](*args: *Ts)). Pack inference now applies the same
default-type fallback that single-argument trait-bound parameters already
use, so foo([1, 2, 3], [4, 5, 6]) resolves each literal to its default
type (e.g. List[Int]) before binding the pack.
Fixed mojo aborting at startup with std::filesystem::filesystem_error
when $HOME is not traversable by the running UID (common in containerized
CI where the image's build-time UID differs from the runtime UID). The
config search now treats permission errors as "not found" and falls through
to the next candidate.
(Issue #6412)
mojo run and mojo debug now honor -Xlinker flags by loading the
referenced shared libraries into the in-process JIT. Previously the flags
were dropped (with a -Xlinker argument unused warning), leaving programs
that called into external shared libraries via external_call unable to
resolve those symbols at runtime (so mojo build worked but mojo run did
not). The supported forms mirror what the system linker accepts: -Xlinker -L<dir>, -Xlinker -l<name>, -Xlinker -rpath <dir>, and -Xlinker <absolute-path-to-shared-library>. Flags that have no meaning under JIT
are reported as a warning and ignored.
(Issue #6155)
Fixed libpython auto-discovery failing for Python 3.14 free-threaded builds.
The discovery script constructed the library filename without the ABI flags
suffix (e.g. looked for libpython3.14.dylib instead of
libpython3.14t.dylib).
(Issue #6366)
Fixed RTLD.LOCAL having the wrong value on Linux. It was set to 4
(RTLD_NOLOAD) instead of 0, causing dlopen with RTLD.NOW | RTLD.LOCAL
to fail. (Issue #6410)
Fixed mojo format crashing after upgrading Mojo versions due to a stale
grammar cache. (Issue #6144)
Fixed atof producing incorrect results for floats near the
normal/subnormal boundary (e.g., Float64("4.4501363245856945e-308")
returned half the correct value).
(#6196)
Issue #5872: Fixed a
compiler crash ("'get_type_name' requires a concrete type") when using
default Writable, Equatable, or Hashable implementations on structs
with MLIR-type fields (e.g. __mlir_type.index). The compiler now correctly
reports that the field does not implement the required trait.
Fixed Atomic.store silently dropping the requested scope. The previous
implementation lowered to atomicrmw xchg without forwarding syncscope,
so Atomic[..., scope="device"].store(...) was emitting a system-scope
store on NVPTX (extra L2/NVLink fences) and an over-synchronized store on
AMDGPU. Atomic.store now lowers via pop.store atomic syncscope(...),
emitting st.release.<scope> on NVPTX and a properly-scoped LLVM atomic
store on AMDGPU. The Mojo API surface is unchanged.
Fixed Process.run() not inheriting the parent's environment variables.
Child processes spawned via Process.run() now correctly receive the
parent's environment.
Fixed \xhh and \ooo escape sequences in string literals being
interpreted as raw bytes instead of Unicode code points, which produced
malformed UTF-8 for values >= 0x80. The escapes now match Python str
semantics (and the existing \u/\U handling): "\x85" encodes U+0085
(NEL) as two UTF-8 bytes and ord("\x85") returns 133 instead of 5.
Code that relied on \xhh to emit a single raw byte for non-ASCII values
must construct the bytes explicitly (for example via a List[Byte]
literal).
(Issue #2842)
Fixed incorrect data layout for MI250X AMDGPU architectures.
(Issue #6451
Official Modular AI agent skills. Modular has released
official AI agent skills for working
with MAX and Mojo. The four skills—new-modular-project, mojo-syntax,
mojo-gpu-fundamentals, and mojo-python-interop—help AI coding agents
create new projects with the right tooling, generate correct modern Mojo
syntax, follow GPU programming best practices, and handle Python-Mojo
interop. The skills follow the open
Agent Skills Standard and work with
Claude Code and other compatible agents. Install them with
npx skills add modular/skills.
Conditional trait conformances. Structs can now declare trait
conformances that apply only when type parameters satisfy certain
conditions, using where clauses in the conformance list. Nine standard
library types—including List, Dict, Set, and Optional—now use
this feature to enforce trait requirements at compile time. See
Language enhancements and
Conditional conformances.
def/fn unification. def is now Mojo's standard function
declaration keyword. def functions no longer implicitly raise and now
have the same semantics as fn: non-raising by default, with explicit
raises for functions that can throw. fn is deprecated and will be
removed in a future release. See
Language enhancements.
T-strings. Mojo now supports template strings with the t"..." prefix.
T-strings produce a TString value that captures both the static format
string and runtime arguments, enabling structured string processing without
immediate allocation. See
Language enhancements.
comptime if and comptime for. The new comptime if and
comptime for syntax replaces the legacy @parameter if and
@parameter for decorator forms for compile-time conditionals and loops.
Both syntaxes are accepted in this release; the @parameter forms will be
deprecated soon. See
Language enhancements.
assert statement. Mojo now supports a standalone assert statement,
similar to Python's assert. It checks a condition at runtime and aborts
if the condition is false, with an optional message. Under the hood,
assert desugars to debug_assert() and respects the -D ASSERT flag.
See Language enhancements.
@align(N) decorator. Structs can now specify minimum alignment with
@align(N), similar to C++ alignas and Rust #[repr(align(N))]. The
alignment value can be a struct parameter, enabling generic cache-aligned
and hardware-aligned types. See
Language enhancements.
Implicit Int to SIMD conversions deprecated. Implicit conversions
from Int to SIMD scalar types like Int8 or Float32 are now
deprecated. Code relying on these conversions should use explicit
constructors instead. The mojo build --experimental-fixit command can
assist with migration. See
Math and numeric types.
Init unification. The __moveinit__() and __copyinit__() methods
are now renamed to __init__() with keyword-only take and copy
arguments, respectively. The legacy names are still accepted but should be
migrated to the modern form. See
Init unification.
Stringable and Representable deprecated. These traits are replaced
by the unified Writable trait, which provides default implementations.
Most standard library types have already had their Stringable and
Representable conformances removed. See
String and text.
UTF-8 safety improvements. String and StringSlice subscripting
now panics when an index falls in the middle of a multi-byte codepoint,
and String.resize() panics on operations that would produce invalid
UTF-8. Byte-position subscripting now returns an entire Unicode codepoint
instead of a single byte. See String and text.
trait no longer inherits ImplicitlyDestructible. Trait declarations
no longer automatically conform to ImplicitlyDestructible; traits that
need it must now opt in explicitly. This continues v0.26.1's work on
explicitly-destroyed types and encourages the ecosystem to support linear
types by default. See
Other changes.
Added a new Mojo tips for Python devs page
to the Mojo Manual, covering key differences Python developers encounter
when learning Mojo. Topics include variable declarations with var,
type annotations, integer vs. floating-point division, implicit conversions,
and other common gotchas. If you're coming from Python, this page helps you
avoid surprises and write idiomatic Mojo faster.
Added a new
Instance initialization deep dive
page to the Mojo Manual. This page explains the difference between logical and
fieldwise initialization, how to write __init__ constructors that satisfy
the compiler's field-by-field initialization requirements, and how copy and
move constructors fit into the initialization model. Essential reading for
anyone working with non-trivial struct types.
Added a new Generics page to the Mojo
Manual with worked examples of conditional trait conformance. The page shows
how to use where clauses to declare that a generic type conforms to a
trait only when its type parameters meet certain conditions, such as making
a container Equatable only when its element type is.
Restructured and expanded the metaprogramming section of the Mojo Manual. This includes a new introduction page, which provides an overview of Mojo's compile-time metaprogramming model, and new pages on compile-time evaluation, reflection, and materialization, as well as the previously-mentioned page on generics. Together these changes cover several previously undocumented topics and provide a smoother learning path from basic parameters to advanced metaprogramming techniques.
Updated the Jupyter Notebooks page with Apple Silicon GPU examples and setup instructions, so macOS users with M-series chips can run GPU-accelerated Mojo code in notebooks without needing an external GPU.
def is now Mojo's standard function declaration keyword. def functions no
longer implicitly raise and now have the same semantics as fn: they are
non-raising by default, accept a raises specifier, and support typed errors.
fn is now deprecated and will be removed in a future release. We recommend
switching all fn declarations to def.
# Previously
def foo(): # Implicitly raised Error.
fn bar(): # Did not raise.
fn baz() raises: # Explicitly raised Error.
fn qux() raises EmptyDictError: # Raised a typed error.
# Now
def foo(): # Does not raise.
def bar() raises: # Explicitly raises Error.
def baz() raises EmptyDictError: # Raises a typed error.
fn qux(): # Deprecated: use 'def' instead.
fn qux() raises: # Deprecated: use 'def' instead.
fn qux() raises EmptyDictError: # Deprecated: use 'def' instead.
This change clarifies function contracts by making error handling explicit:
a def without raises guarantees that errors are handled locally or cannot
occur, and the compiler enforces this no-throw guarantee.
Mojo now supports conditional trait conformances on struct declarations.
A struct can declare that it conforms to a trait only when its type parameters
satisfy certain conditions, using where clauses in the conformance list.
The where clause accepts any
Bool-typed parameter
expression. For example,
List now uses this to
conditionally conform to
Equatable and
Writable only when its
element type does:
struct List[T: Movable](
Copyable,
Equatable where conforms_to(T, Equatable),
Movable,
Writable where conforms_to(T, Writable),
):
...
Here is a small self-contained example:
@fieldwise_init
struct Wrapper[T: Copyable & ImplicitlyDestructible](
Writable where conforms_to(T, Writable),
):
var value: Self.T
@fieldwise_init
struct NotWritable(Copyable, ImplicitlyDestructible):
var data: Int
def main():
var w = Wrapper[Int](42)
print(w) # OK — Int is Writable. Prints: Wrapper[Int](value=42)
var w2 = Wrapper[NotWritable](NotWritable(10)) # OK to construct
print(w2) # errors at parse time
Current limitations: Conditional conformance to
RegisterPassable,
TrivialRegisterPassable,
and
ImplicitlyDestructible
is not yet supported.
Mojo now supports t-strings (template strings) for building structured
string templates with interpolated expressions. T-strings use the t"..."
prefix and produce a
TString value that
captures both the static format string and any runtime
arguments, rather than immediately producing a
String:
def main():
var x = 10
var y = 20
print(t"{x} + {y} = {x + y}") # prints: 10 + 20 = 30
Use {{ and }} to include literal braces in the output:
print(t"Use {{braces}} like this") # prints: Use {braces} like this
Mojo now supports comptime if and comptime for as the preferred syntax
for compile-time conditional and loop constructs, replacing the legacy
@parameter if and @parameter for decorator forms:
# Old syntax (still accepted, deprecated in a future release)
@parameter
if some_condition:
...
@parameter
for i in range(10):
...
# New syntax
comptime if some_condition:
...
comptime for i in range(10):
...
Both syntaxes are accepted in this release. The @parameter forms will be
deprecated soon, and the parser will generate a warning and a fixit suggestion
to migrate to the new syntax.
Mojo now supports a standalone assert statement, similar to Python's
assert. It checks a condition at runtime and aborts the program if the
condition is false:
assert x > 0, "x must be positive"
assert len(items) != 0
The condition must be a Bool expression and the optional
message can be any Writable expression (StringLiteral,
String, Int, etc.). Under
the hood, assert desugars to a call to
debug_assert(),
so it respects the
existing -D ASSERT flag: assertions are active when compiled with
-D ASSERT=all and are no-ops otherwise.
Mojo now supports the
@align(N) decorator to
specify minimum alignment for structs, similar to C++'s
alignas and Rust's #[repr(align(N))]. The value
N must be a positive power of 2 and specifies the minimum alignment in
bytes. The actual alignment is max(N, natural_alignment)—you cannot
use @align to reduce alignment below the struct's natural alignment. For
example, @align(1) on a struct containing an Int (8-byte aligned) will
emit a warning and the struct will remain 8-byte aligned.
from sys import align_of
@align(64)
struct CacheAligned:
var data: Int
def main():
print(align_of[CacheAligned]()) # Prints 64
Both stack and heap allocations respect @align.
The alignment value can also be a struct parameter, enabling generic aligned types:
@align(Self.alignment)
struct AlignedBuffer[alignment: Int]:
var data: Int
def main():
print(align_of[AlignedBuffer[64]]()) # Prints 64
print(align_of[AlignedBuffer[128]]()) # Prints 128
Mojo now supports specifying a default value for an inferred parameter, making it easier to create a partially bound type:
struct Pointer[mut = False, // o: Origin[mut]] : pass
# Default to immutable pointer
comptime ImmPointer = Pointer[_]
# Explicitly set to mutable pointer
comptime mutPointer = Pointer[mut = True, _]
# Inferred mutability from `SomeOrigin()`
comptime InferredPointer = Pointer[SomeOrigin()]
# Parametric mutability pointer.
comptime ParametricPointer = Pointer[...]
Mojo now enforces more explicit parameter binding rules:
[] is mandatory to make type more concrete:
struct SomeStruct[a : Int = 1]:
pass
# SS1 is a parametric type
comptime SS1 = SomeStruct
# SS2 a concrete type alias of `SomeStruct[1]
comptime SS2 = SomeStruct[]
When [] is used, it must produce a concrete type unless _/... is used
to unbind a specific/multiple missing parameters.
struct SomeStruct[a : Int, b: Int, c: Int = 2]:
pass
# Error: can not infer `b`, since `[]` must produce a concrete type, without `_`/`...``
comptime SS1 = SomeStruct[1]
# This is a concrete type alias of `SomeStruct[1, 1, 2]`
comptime SS2 = SomeStruct[1, 1]
# Using `...` defers binding of b and c, and produces `SomeStruct[1, ?, ?]` (preserving possible defaults)
comptime SS3 = SomeStruct[1, ...]
# Even though SS3 unbinds `c`, Mojo keeps track of the fact that there is a default value for c:
# This install b (using 1) and c (using default value), and produce `SomeStruct[1, 1, 2]`
comptime SS4 = SS3[1]
# This installs the default and is identical to `SomeStruct[1, ?, 2]`
comptime SS5 = SomeStruct[1, _]
# This unbind the default explicitly and is identical to `SomeStruct[1, ?, ?]`
comptime SS6 = SomeStruct[1, _, _]
# The following two are equivalent:
comptime SS7 = SomeStruct
comptime SS8 = SomeStruct[...]
Mojo now supports more flexible default arguments and parameters, which can mismatch on declared type when their types are parametric. This allows inferring parameters from these when they are used as a default value, for example:
def take_string_slice[o: ImmOrigin](str: StringSlice[o] = ""): ...
def use_it():
take_string_slice() # Ok, defaults to empty string, inferring "o".
# Explicit calls also work of course.
take_string_slice(StaticString("hello"))
# Default value is checked for validity at the call site.
def defaultArgumentBadType2[T: AnyType](a: T = 1.0): pass
def callDefaultArgumentBadType2():
# Ok!
defaultArgumentBadType2[Float64]()
# error: value passed to 'a' cannot be converted from 'FloatLiteral[1]' to 'Int'
defaultArgumentBadType2[Int]()
Mojo now allows move constructors to take their "take" argument as either
deinit or var. deinit should be generally preferred, but var can be
useful in unusual cases where you want C++-like behavior where the destructor
still runs on the value after the move constructor is done with it.
def __init__(out self, *, var take: Self):
self.data = munge(take.data)
# take.__del__() runs here.
As part of "init unification", the __moveinit__() and __copyinit__()
methods
are now renamed
to fn __init__(out self, *, take: Self) and
fn __init__(out self, *, copy: Self) respectively. Mojo now accepts these
names for initializers, but also supports the legacy __moveinit__() and
__copyinit__() names as well (for now). However, the argument name for these
legacy methods must now be named take and copy respectively. Please move
to the more modern __init__ names when possible.
As part of init unification, the __moveinit__is_trivial and
__copyinit__is_trivial members of
Movable and
Copyable have been
renamed
to __move_ctor_is_trivial and __copy_ctor_is_trivial respectively.
@register_passable("trivial") is now deprecated. Conform to the
TrivialRegisterPassable trait instead. The decorator will be removed
after the next release.
@register_passable is now deprecated. Conform to the RegisterPassable
trait instead. The decorator will be removed after the next release.
LegacyUnsafePointer is now deprecated. Use
UnsafePointer
instead.
Check the docstrings in unsafe_pointer.mojo for guidance on migration.
LegacyUnsafePointer will be removed after the next release.
comptime assertUnstable __comptime_assert syntax is now finalized as comptime assert. A
deprecation warning is emitted with a fixit for the old syntax.
comptime assert no longer errors on always-false conditions. The assertion
will only trigger if its parent scope is concretized.
A statically False comptime assert now ends a scope. Any code following it
in the same scope is now a warning, and can be removed.
**_ and *_ are no longer supported in parameter binding lists. Use a more
concise ... to unbind any unspecified parameter explicitly.
Homogeneous variadic parameters are now passed with the
VariadicParamList
type (formerly known as VariadicList) and arguments are
now consistently passed with
VariadicList
(formerly VariadicListMem) instead
of trivial types being passed directly.
Slice literals in subscripts have changed to be more similar to collection
literals. They now pass an empty tuple as a required __slice_literal__
keyword argument to disambiguate slices. If you have defined your own range
types, please add a __slice_literal__: () = () argument to their
constructors.
trait declarations no longer automatically inherit from
ImplicitlyDestructible. struct declarations are not changed, and continue
to inherit from ImplicitlyDestructible.
Previously, the
@explicit_destroy
annotation was required to opt-out of
ImplicitlyDestructible conformance. Now, if a trait's usage depends on
implicit destructibility, it must opt-in explicitly:
# Before
trait Foo:
...
# After:
trait Foo(ImplicitlyDestructible):
...
Conversely, if a trait wanted to support non-implicitly-destructible types,
it no longer needs to be annotated with @explicit_destroy:
# Before
@explicit_destroy
trait Foo:
...
# After
trait Foo:
...
Making struct continue to inherit from ImplicitlyDestructible and not
trait is intended to balance usability and familiarity in the common case,
with the need to foster broad Mojo ecosystem support for explicitly destroyed
types.
It's not a problem if the majority of struct types are
ImplicitlyDestructible in practice. However, if many ecosystem libraries are
written with unnecessary ImplicitlyDestructible bounds, that would hamper
the usability of any individual struct type that opts-in to being explicitly
destroyed.
Libraries with generic algorithms and types should be written to accommodate
linear types. Making ImplicitlyDestructible opt-in for traits
encourages a default stance of support, with specific types and functions
only opting-in to the narrower ImplicitlyDestructible requirement if they
truly need it.
The majority of generic algorithms that take their inputs by reference should not be affected.
Re-exported symbols from a package's __init__.mojo are no longer shadowed
by a submodule of the same name. For example, if pkg/foo.mojo defines
fn foo and pkg/__init__.mojo does from .foo import foo, then
from pkg import foo and from pkg import * now correctly resolve to the
function rather than the module.
is_compile_time() has been renamed to __is_run_in_comptime_interpreter,
which is now a keyword rather than a function call. It provides a mechanism
for supporting different code execution paths in the comptime interpreter
versus runtime-generated code. This value cannot be used as a constant in any
comptime expressions because it is always evaluated as True for comptime
expressions. Use the check as a condition for runtime if. The compiler now
warns if it is used as a condition for comptime if.
Mojo supports indexing with subscripts and names using the standard Python
__getitem__() and __getattr__() methods. Previously it used a heuristic to
determine whether a __get*__ method was operated with dynamic or parameter
indexes. Mojo now has a simple and explicit policy: if a type implements a
__getitem_param__() or __getattr_param__() method and the indices are
valid parameter expressions, the compiler will pick it (but will not support a
__setitem__() pair). If not or if the indices are only valid runtime values,
Mojo will try __getitem__()/__setitem__() as usual. This makes the
behavior more predictable and explicit, but requires types to switch to the
param method names if they desire parameter-style subscripting. This only
affects a small number of special types like Tuple and VariadicPack.
The @doc_private decorator has been renamed to @doc_hidden to better
reflect its purpose of hiding declarations from documentation generation,
rather than implying any change in access control. The old @doc_private name
is still accepted but deprecated and will be removed in a future release.
Dict now uses real
conditional conformances for Writable. The Dict type
only conforms to Writable when both its key and value types do, enforced at
compile time via where clauses.
Standard library types now use conditional conformances, replacing previous
_constrained_conforms_to checks:
Deque:
Equatable,
Hashable, WritableDict: Writable, Equatable, HashableInlineArray:
Copyable, Equatable, Hashable, WritableLinkedList:
Equatable, Hashable, WritableList: Equatable, Hashable, WritableOptional:
Hashable, Writable, Copyable,
ImplicitlyCopyableSet: Copyable,
Comparable,
Equatable, Hashable, WritableTuple: Copyable,
Equatable, Hashable, ImplicitlyCopyable, WritableVariant: WritableDict internals have been replaced with a Swiss Table implementation using
SIMD group probing for lookups. This improves lookup, insertion, and deletion
performance—especially when looking up keys not in the dict—while
increasing the load factor from 2/3 to 7/8 for better memory efficiency.
The power_of_two_initial_capacity keyword argument has been renamed to
capacity and now accepts any positive integer (it is rounded up to the
next power of two internally, minimum 16).
Dict now performs in-place tombstone rehashing when the table is full of
tombstones but the live element count is low. This prevents unnecessary
capacity doubling after repeated insert/delete cycles.
StaticTuple now supports
comparison operators. __eq__()/__ne__() are available when
element_type: Equatable, and __lt__()/__le__()/__gt__()/ __ge__()
are available when element_type: Comparable. All use lexicographic ordering
with compile-time unrolled loops.
Set.pop() now uses
Dict.popitem()
directly, avoiding a redundant rehash.
Order changes from FIFO to LIFO, matching Python's unordered set.pop().
Set.__gt__() and Set.__lt__() now use an O(1) len() check plus a single
issubset() traversal instead of two full traversals.
InlineArray now requires explicitly using literals for construction.
For example:
var a: InlineArray[UInt8, 4] = [1, 2, 3, 4]
# instead of InlineArray[UInt8, 4](1, 2, 3, 4)
The following types now correctly implement write_repr_to():
List, SetThe itertools module now includes
three new iterator combinators:
cycle(iterable):
Creates an iterator that cycles through elements
indefinitelytake_while[predicate](iterable):
Yields elements while the predicate returns Truedrop_while[predicate](iterable):
Drops elements while the predicate returns True, then yields the restThe Stringable and Representable traits are now deprecated. Use Writable
instead to make your types formattable as strings.
Writable provides a default implementation, so in many cases simply adding
Writable conformance is enough without manually implementing write_to()
or write_repr_to(), however, you can manually implement these to get custom
output.
The stdlib is beginning to remove support for the Stringable
and Representable traits in favor of the unified Writable trait.
Most stdlib types have had their conformance to Stringable and
Representable removed and the associated __str__()
and __repr__() methods have been deprecated.
The __reversed__() method on String,
StringSlice,
and StringLiteral
has been deprecated in favor of the new codepoints_reversed() method. The
new method name makes it explicit that iteration is over Unicode codepoints
in reverse order, maintaining consistency with the existing codepoints()
and codepoint_slices() methods. The deprecated __reversed__() methods
will continue to work but will emit deprecation warnings.
The StringSlice constructor from String now propagates mutability. If you
have a mutable reference to a String, StringSlice(str) returns a mutable
StringSlice. The
String.as_string_slice()
method is now deprecated in
favor of the StringSlice(str) constructor, and
String.as_string_slice_mut()
has been removed.
String.ljust(),
String.rjust(), and String.center() have been renamed
to
String.ascii_ljust(), String.ascii_rjust(), and String.ascii_center().
Likewise for their equivalents on StringSlice and StaticString.
String.resize()
will now panic if the new length would truncate a
codepoint.
Previously it would result in a string with invalid UTF-8.
String.resize() will now panic if fill_byte is >=128. Previously it would
create invalid UTF-8.
Subscripting into String and StringSlice will now panic if the index falls
in the middle of a UTF-8 encoded codepoint. Previously they would
return invalid
UTF-8. This panic is unconditional. Use .as_bytes()[...] if you really want
the previous behavior.
StringSlice[byte=] subscripting now returns a StringSlice instead of a
String. This is consistent with range-based subscripting.
Subscripting String and StringSlice by byte position will
now return an entire Unicode codepoint. Previously it would
return a single byte, and produce invalid UTF-8 if the index fell on
the starting byte of a multi-byte codepoint.
String, StringSlice, and StringLiteral's .format() method now require
their arguments to be Writable.
TString.write_to() now uses a compact encoding for format
strings. The
format string is flattened at compile time into NUL-terminated literal
segments, producing considerably smaller static data and faster runtime than
the previous struct-based precompiled entries.
Formatting compile-time format strings (StringLiterals) no longer allocates
memory. It uses global_constant to store what would be heap-allocated
parsed formatting data.
T-strings now support the raw prefix (rt"...") which preserves backslashes
as literal characters while still supporting interpolation.
var name = "Mojo"
print(t"C:\{name}\Documents") # prints "C:\Mojo\Documents"
Subscripting String and StringSlice now requires a named parameter for
range indexing. For example, s[1:3] is now s[byte=1:3].
Bool no longer conforms to the
Indexer trait. Previously,
Bool could be
used to index into collections (for example, nums[True]), which
is not desirable
behavior for a strongly-typed language. Use Int(my_bool) to explicitly
convert a Bool to an index.
The following types now conform to Writable and have custom implementations
of write_to() and write_repr_to().
TupleVariantOptionalAll traits and structs with the @register_passable("trivial") decorator now
extend the TrivialRegisterPassable trait. The decorator is removed
from them.
A new utils/type_functions module was added for holding type functions. Type
functions are comptime declarations that produce a type from compile-time
parameter inputs. Unlike regular fn functions which accept and
return runtime
values, type functions operate entirely at compile time—they take comptime
parameters and evaluate to a type, with no runtime component.
ConditionalType—A type function that conditionally selects between two
types based on a compile-time boolean condition. It is the type-level
equivalent of the ternary conditional expression Then if If else Else.reflection/traits has been added, providing compile-time meta functions
(AllWritable, AllMovable, AllCopyable, AllImplicitlyCopyable,
AllDefaultable, AllEquatable) that evaluate to True if all types in a
variadic type list conform to the corresponding trait.
Added the UnsafeNicheable and UnsafeSingleNicheable traits to
std.utils. These traits allow types to expose known-invalid bit patterns
("niches") that can be used by containers like Optional and
Variant to avoid
storing a separate tag, so that size_of[Optional[T]]() == size_of[T]().
UnsafeSingleNicheable is a simplified subtrait for the common case where a
type has exactly one niche value.
Variant and Optional now automatically take advantage of this: when the
variant types qualify, the discriminant tag is elided entirely, reducing the
size of the variant. For example, size_of[Optional[T]]() == size_of[T]()
for any T that implements UnsafeNicheable.Variant also only works with Movable types in the interim instead of
AnyType due to some compiler limitations.Implicit conversions from Int to SIMD are
now deprecated, and will be removed in a future version of Mojo. This includes
deprecating conversions from Int to specific SIMD scalar types like Int8
or Float32.
Note: The experimental
mojo build --experimental-fixitcommand may be useful in assisting with migrating your code to reflect this change.
Code currently relying on implicit conversions, for example:
def foo(arg: Int) -> Float32:
return arg
should be changed to use an explicit conversion:
def foo(arg: Int) -> Float32:
return Float32(arg)
Occasionally, when an implicit conversion was happening from a scalar Int to
a wider SIMD value, the compiler will suggest a change to make the
conversion explicit that is somewhat verbose, performing both the type
conversion and the "splat" in a single step:
var bits: SIMD[DType.uint8, 16] = ...
- var y = bits >> (j * 4)
+ var y = bits >> SIMD[DType.uint8, 16](j * 4)
a simpler change is to make the type conversion explicit, and let the "splat" continue to happen implicitly (which will remain supported):
var bits: SIMD[DType.uint8, 16] = ...
- var y = bits >> (j * 4)
+ var y = bits >> UInt8(j * 4)
A similar overly verbose suggestion can be emitted relating to
LayoutTensor.element_type, where the compiler may suggest a change of the
form:
- tensor[i] = i * l
+ tensor[i] = LayoutTensor[DType.uint32, Layout(IntTuple(-1)), stack].element_type(i * l)
where a simpler change is sufficient:
- tensor[i] = i * l
+ tensor[i] = UInt32(i * l)
# Note: If the tensor's `dtype` is not statically known, this works as well:
+ tensor[i] = Scalar[tensor.dtype](i * l)
SIMD's safe division operators (__floordiv__, __mod__, __divmod__)
now return safe results in an elementwise fashion. They previously returned a
zero result if any element of the divisor was zero:
comptime Int32x2 = SIMD[DType.int32, 2]
var a = Int32x2(99, 99)
var b = Int32x2(4, 0)
# Now returns [24, 0]
# Previously returned [0, 0]
print(a.__floordiv__(b))
Int.__truediv__()
now performs truncating integer division, returning Int
instead of the previously deprecated Float64. Use explicit Float64 casts
for floating-point division.
Documentation for
SIMD.__round__()
now clarifies the pre-existing behavior
that ties are rounded to the nearest even, not away from zero.
Int.write_padded()
now accounts for a negative sign when calculating the
width, resulting in a consistent width regardless of sign:
Int(1).write_padded(s, 4) # writes " 1"
Int(-1).write_padded(s, 4) # writes " -1"
SIMD now has a write_padded() method for integral
DTypes, matching the
behavior of Int.write_padded(). The padding is added elementwise. Unlike
SIMD regular printing, there are no spaces added between elements by
default:
Int32(1).write_padded(s, 4) # writes " 1"
Int32(-1).write_padded(s, 4) # writes " -1"
# "[ 1, -1, 0,1234]"
SIMD[DType.int32, 4](1,-1,0,1234).write_padded(s, 4)
# "[255,255]"
SIMD[DType.uint8, 2](255).write_padded(s, 1)
Added comb(n, k) and
perm(n, k) to std.math,
matching Python's
math.comb() and math.perm(). comb(n, k) computes the binomial
coefficient C(n, k) without computing full factorials, returning 0 when
k > n. perm(n, k) computes permutations P(n, k); omitting k (default
-1) returns n!.
The builtin.math module has been merged into
math. The traits
Absable,
DivModable,
Powable,
Roundable and functions
abs(),
divmod(), max(),
min(), pow(),
round() are now part of the
math module and
continue to be available in the prelude. Code that explicitly imported from
builtin.math should update to import from math instead.
Math functions in std.math (exp(), exp2(), log2(), erf(), tanh(),
sin(), cos(), tan(), acos(), asin(), atan(), atan2(),
acosh(), asinh(), atanh(), cosh(), sinh(), expm1(), log10(),
log1p(), logb(), cbrt(), erfc(), j0(), j1(), y0(), y1())
now use where dtype.is_floating_point() clauses on their
signatures instead of __comptime_assert checks in their bodies.
This provides better compile-time error messages at the call site. Callers
using these functions with generic dtype parameters may need to add
evidence proving (either a where clause or __comptime_assert) that their
type is floating point.
Added
uninit_move_n(),
uninit_copy_n(),
and
destroy_n()
functions to the memory module for
efficient bulk memory operations. These functions handle
moving, copying, and destroying multiple values in contiguous memory, with
automatic optimization for trivial types using memcpy. They encapsulate the
common pattern of checking __move_ctor_is_trivial, __copy_ctor_is_trivial,
or __del__is_trivial and selecting the appropriate implementation.
The List
collection now uses these functions internally for improved code clarity and
maintainability.
The Origin
struct now takes the underlying MLIR origin as a parameter
instead of storing it. This follows the design of IntLiteral and related
types, and fixes some memory safety problems.
UnsafeMaybeUninit
has been renamed as such, and its methods have had their
names updated to reflect the init name. It also now exposes a
zeroed() method
to get zeroed out uninitialized memory. It also no longer calls abort() when
being copied or moved, allowing for more practical uses.
Span[T] is no longer
restricted to Copyable types. It now works with
T: AnyType.
There are a few restrictions including iteration requiring T: Copyable.
lane_group_sum(),
lane_group_max(),
and
lane_group_min()
in
std.gpu.primitives.warp now always broadcast the reduction result to all
participating lanes, using optimized hardware-specific paths (AMD DPP,
Blackwell redux, or butterfly shuffle pattern). The previous
lane_group_sum_and_broadcast(), lane_group_max_and_broadcast() functions
are deprecated—use the short names instead.
TileTensor now supports
hierarchical indexing. For example, a TileTensor with shape (4, (3, 2))
can be indexed by (1), (1, 1), or (1, (1, 1)).
TileTensor now supports flattening up to depth-4.
Many kernels in nn have been migrated to use TileTensor. We will have
more documentation on TileTensor and its uses over the coming weeks.
The ffi module is now a top-level module
in the standard library, rather
than being nested under sys. This improves discoverability of FFI
functionality. Update your imports from from sys.ffi import ... to
from ffi import ....
Added
UnsafeUnion[*Ts],
a C-style untagged union type for FFI
interoperability. Unlike Variant, UnsafeUnion does not track which type
is stored (no discriminant), making it suitable for interfacing with C unions
and low-level type punning. The memory layout exactly matches C unions (size
is max of elements, alignment is max of elements).
All element types must have trivial copy, move, and destroy operations, matching C union semantics where types don't have constructors or destructors.
Construction is explicit (no implicit conversion) to emphasize the unsafe
nature of this type. All accessor methods are prefixed with unsafe_ to make
it clear that these operations are unsafe.
from ffi import UnsafeUnion
# Define a union that can hold Int32 or Float32
comptime IntOrFloat = UnsafeUnion[Int32, Float32]
var u = IntOrFloat(Int32(42))
print(u.unsafe_get[Int32]()) # => 42
print(u) # => UnsafeUnion[Int32, Float32](size=4, align=4)
# Type punning (reinterpreting bits)
var u2 = IntOrFloat(Float32(1.0))
print(u2.unsafe_get[Int32]()) # => 1065353216 (IEEE 754 bits)
The env_get_bool(), env_get_int(), env_get_string(), and
env_get_dtype() functions in the sys.param_env module have been renamed to
get_defined_bool(), get_defined_int(), get_defined_string(), and
get_defined_dtype() in the new sys.defines module. The
new names better reflect that these functions read
compile-time defines (set via -D), not runtime environment
variables. The
is_defined() function
has also moved to
sys.defines without renaming. The old names in sys.param_env are
deprecated but still available.
The testing module now provides
assert_equal
and
assert_not_equal
overloads for Tuple, enabling direct tuple-to-tuple comparisons in tests
instead of element-by-element assertions. Element types must conform to
Equatable & Writable.
assert_equal and assert_not_equal now work with types implementing
Writable.
Changed
CompilationTarget.unsupported_target_error()
to return Never
and
removed its result type parameter.
Removed DType.get_dtype[T]() and DType.is_scalar[T](). These
were low-level
operations for extracting the DType of a SIMD in generic code. There are
better alternatives available in Mojo today using reflection capabilities.
perf_counter_ns() now returns
correct nanoseconds on GPU instead of raw cycle counts. Previously on NVIDIA
GPUs it used clock64 (a cycle counter dependent on GPU core clock
frequency); it now uses globaltimer which provides actual nanosecond
resolution. On AMD GPUs, it now uses s_memrealtime (a constant-speed
real-time clock) instead of s_memtime (a cycle counter).
The DimList type has moved to
representing its dimensions as parameters to the type instead of values inside
the type, directly reflecting that the dimensions are known at compile time.
Change DimList(x, y) to DimList[x, y]().
The Mojo compiler now accepts conjoined -D options in addition to the
non-conjoined form as before. Now, both -Dfoo and -D foo are accepted.
mojo build now supports several --print-* options for discovering target
configuration and supported architectures:
--print-effective-target: Shows the resolved target configuration after
processing all command-line flags.--print-supported-targets: Lists all available LLVM target architectures.--print-supported-cpus: Lists valid CPU names for a given target triple
(requires --target-triple).--print-supported-accelerators: Lists all supported GPU and accelerator
architectures (NVIDIA, AMD, Apple Metal).mojo format now only formats Mojo files (.mojo, .🔥) by default when
run on a directory. Previously it would also format Python files, which
conflicted with Python-specific formatters in pre-commit hooks. Users who
want to format Python files can use mblack directly.
mojo format now supports --print-cache-dir (hidden, use --help-hidden
to see it) to display the path to the formatter cache directory.
mojo build --emit=asm now also emits GPU kernel assembly files alongside
the host .s output. For NVIDIA targets, PTX is written as
<out>_<kernelfn>.ptx; for Apple Metal targets, LLVM IR is written as
<out>_<kernelfn>.ll; for AMD targets, .amdgcn files are written.
Multiple kernels generated from the same function are disambiguated with a
numeric suffix (for example, <out>_<kernelfn>_1.ptx).
mojo doc is now more consistent with Python in its treatment of private
members. Any member name starting with an underscore (_) is treated as
private unless it is a "dunder" member (starting and ending with
double-underscores). In practice this means that members that start but don't
end with double underscores (__example()) are now treated as private. Dunder
methods that start with __mlir are now treated as public unless marked with
the @doc_private decorator.
The .🔥 (flame) and 📦 (package) emoji file extensions are no longer
supported. Use .mojo for all Mojo source files and __init__.mojo for
package initialization files. The emoji extensions were removed
to simplify the tooling and improve compatibility across different
systems and editors.
The owned keyword has been removed. Use var for parameters or deinit
for __moveinit__/__del__ arguments as appropriate.
Dict.EMPTY and Dict.REMOVED comptime aliases have been removed. These
were internal implementation details of the old hash table design.
The @nonmaterializable decorator has been renamed to @__nonmaterializable.
This decorator should not be used outside the standard library, and might be
removed in a future release.
Fixed a bug where Mojo incorrectly passed or returned structs in extern C
function calls. The compiler now applies platform ABI coercion (System V
AMD64 on x86-64, AAPCS on ARM64) when lowering external calls, decomposing
structs into the register types the C ABI requires—matching the behavior of
Clang and Rust. This resolves silent wrong-answer bugs when calling C
functions that take or return struct types.
Issue #5845: Functions raising custom type with conversion fails when returning StringSlice
Issue #5722: __del__
incorrectly runs when __init__ raises before all fields are initialized.
Issue #5875: Storing
SIMD[DType.bool, N] with width > 1 to a pointer and reading back
element-wise now returns correct values.
StringSlice.find:
Fixed integer overflow bug in SIMD string search that caused searches to fail
when searching for strings longer than simd_width_of[DType.bool]() and
haystacks larger than UInt16.MAX.
LinkedList.reverse():
Fixed missing prev pointer updates, which caused __reversed__() to produce
wrong results after reversing.
Mojo would previously consider types Movable if they had a __moveinit__()
method, even if they didn't conform to Movable. Movability is now tied to
the conformance which implies the method.
Special thanks to our community contributors:
Amit Vijairania (@avijaira), Bernardo Taveira (@bertaveira), Brian Carroll (@brian-carroll), Brian Grenier (@bgreni), Byungchul Chae (@byungchul-sqzb), Derek Veit (@DerekVeit), Dylan Walker Brown (@walkerbrown), elpres (@elpres), Evan Owen (@ulmentflam), Joseph Wakeling (@JosephWakeling), josiahls (@josiahls), Krish Gupta (@KrxGu), lamija-i (@lamija-i), Mahendra Singh Rathore (@mahendrarathore1742), Manuel Saelices (@msaelices), martinvuyk (@martinvuyk), minkyu (@kkimmk), nejraberberovic (@nejraberberovic), Parsa Bahraminejad (@prsabahrami), pei0033 (@pei0033), Sören Brunk (@sbrunk), Taesu Kim (@tae-su-kim), Tolga Cangöz (@tolgacangoz), turakz (@turakz)
]]>Expanded reflection module. The reflection module now provides extensive
compile-time introspection: struct field enumeration, types, and byte offsets;
source location tracking; and trait conformance checking on dynamically
obtained types. These APIs enable advanced metaprogramming patterns like
automatic serialization and debug formatting. See Reflection and
introspection.
Explicitly-destroyed types. Mojo now has first-class support for
explicitly-destroyed types (sometimes referred to as "linear types"). The
AnyType, Movable, and Copyable traits no longer require a __del__()
method; use ImplicitlyDestructible when you need implicit destruction.
Explicitly-destroyed types let you encode powerful invariants requiring
explicit resource handling. See Language changes and
Explicitly-destroyed types.
Typed errors. Functions can now specify what type they raise instead of
defaulting to Error (for example, fn foo() raises CustomError -> Int).
Typed errors are highly efficient—they compile to an alternate return value
with no stack unwinding—making them suitable for GPU and embedded targets.
See Language enhancements.
Traits with default implementations. The Hashable, Writable, and
Equatable traits now provide default implementations that automatically
derive behavior from struct fields using reflection. Simple structs can
conform to these traits without writing any boilerplate—just ensure all fields
conform to the same trait. See Traits with default
implementations.
UInt type redesign. The UInt struct has been replaced by a type alias
to Scalar[DType.uint], enabling more powerful generic programming over
unsigned SIMD data types of machine word size. See Other library
changes.
String UTF-8 safety. String now offers three explicit constructors for
raw bytes: from_utf8= (validates and raises on error), from_utf8_lossy=
(replaces invalid sequences with �), and unsafe_from_utf8= (no validation).
This makes UTF-8 handling guarantees explicit at construction time. See
String and text.
The new Mojo quickstart page provides a "5-minute" introduction to installing Mojo and exploring basic language features.
The new Reflection page describes Mojo's new compile-time reflection capabilities, including example use cases.
Added a section to the Value destruction page about how to implement and use explicitly-destroyed types.
The new Jupyter Notebooks page provides step-by-step instructions for programming with Mojo in Google Colab and local JupyterLab environments, including GPU programming examples.
The new Materialization page describes how to make compile-time values available at run time.
Mojo now supports raising "typed errors", where a function can specify what
type it raises instead of defaulting to the
Error type. This is done by specifying it
after the raises keyword, for example, fn foo() raises CustomError -> Int.
Raised errors in Mojo are very efficient - they work as an alternate return
value: for example, a function like fn () raises Int -> Float32: compiles
into code that returns either an Int or a Float32 and uses an implicit
boolean result to determine which one is valid - there is no expensive stack
unwinding or slow dynamic logic that is implied. This means that thrown errors
work fine on GPUs and other embedded targets.
The 'caught' type in a try block is automatically inferred to be the first
thrown type inside of the try body, for example:
try:
print(foo())
except err: # "err" is typed as CustomError
print(err)
Typed throws "just work" with generics, allowing the definition of higher order functions like:
fn parametric_raise_example[ErrorType: AnyType](fp: fn () raises ErrorType) raises ErrorType:
# ... presumably some iteration or other exciting stuff happening here.
fp()
This dovetails with other support to allow contextually generic thrown types, for example:
fn call_parametric_raise_example[GenTy: AnyType](func_ptr: fn () raises GenTy):
fn raise_int() raises Int: pass
try:
parametric_raise_example(raise_int)
except err_int: # Typed as Int
ref x: Int = err_int
fn raise_string() raises String: pass
try:
parametric_raise_example(raise_string)
except err_string: # Typed as String
ref s: String = err_string
try:
parametric_raise_example(func_ptr)
except err_gen: # Typed as GenTy
ref s: GenTy = err_gen
# Non-raising functions infer an error type of `Never`, allowing these
# functions to propagate non-raisability across generic higher-order
# functions conveniently.
fn doesnt_raise(): pass
# Note this isn't in a try block. Mojo knows 'parametric_raise_example'
# doesn't raise because the 'doesnt_raise' function doesn't.
parametric_raise_example(doesnt_raise)
As part of this, context managers have been extended to support typed throws, and can also infer an error type if they need to handle it, for example:
struct MyGenericExitCtxtMgr:
# Called on entry to the with block.
fn __enter__(self): ...
# Called on exit from the with block when no error is thrown.
fn __exit__(self): ...
# Called on exit from the with block if an error is thrown.
fn __exit__[ErrType: AnyType](self, err: ErrType) -> Bool: ...
Mojo now supports a Never type,
which can never be instantiated. This type can be used for functions (like
abort()) which do not have a
normal return value, and for functions that are guaranteed to raise without
returning a normal value. Functions that are declared to raise Never (and
generic functions instantiated with Never as their error type) compile into
the same ABI as functions that don't raise.
Mojo now allows the use of a comptime(x) expression to force a subexpression
to be evaluated at compile time. This can help make working with certain
types more elegant when you can't (or don't want to) materialize them into a
runtime value. For example, if you just want the size from a compile time
layout:
fn takes_layout[a: Layout]():
# materializes entire layout value just to get the size out of it
print(a.size())
# Could already work around this with a comptime declaration, verbosely.
comptime a_size = a.size()
print(a_size)
# Can now tell Mojo to evaluate the expression at comptime.
print(comptime(a.size()))
Mojo now differentiates between ... and pass in trait methods. The use of
... continues to denote no default implementation—pass now specifies a
default do-nothing implementation. For example:
trait T:
# No default implementation
fn foo(self): ...
# Default implementation that does nothing
fn bar(self) : pass
The compiler will error on the use of pass to define a default
implementation for a trait method with results:
trait T:
foo.mojo:2:26: error: trait method has results but default implementation returns no value; did you mean '...'?
fn foo(self) -> Int: pass
^
trait.mojo:2:8: note: in 'foo', declared here
fn foo(self) -> Int: pass
^
Mojo now allows implicit conversions between function types from a non-raising function to a raising function. It also allows implicit conversions between function types whose result types are implicitly convertible.
fn takes_raising_float(a: fn () raises -> Float32): ...
fn returns_int() -> Int: ...
fn example():
# This is now ok.
takes_raising_float(returns_int)
Mojo now allows functions that return references to convert to functions that return values if the type is implicitly copyable or implicitly convertible to the destination type:
fn fn_returns_ref(x: SomeType) -> ref [x.field] Int: ...
fn examples():
# OK, Int result from fn_returns_ref can be implicitly copied.
var f1 : fn (x: SomeType) -> Int = fn_returns_ref
# OK, Int result from fn_returns_ref implicitly converts to Float64.
var f2 : fn (x: SomeType) -> Float64 = fn_returns_ref
Context managers (used in with statements) can now define consuming exit
methods—that is, fn __exit__(var self)—which can be useful for
explicitly-destroyed context managers. This also works with deinit.
The deinit argument convention can now be applied to any argument of a
struct method, but the argument type still must be of the enclosing struct
type.
Mojo now supports the ... expression. It is a logically empty value of
EllipsisType. It can be used
in overloaded functions, for example, getitem() calls:
struct YourType:
fn __getitem__(self, idx: Int) -> Int:
# ... behavior when passed x[i]
fn __getitem__(self, idx: EllipsisType) -> Int:
# ... behavior when passed x[...]
The Mojo language basic trait hierarchy has changed to expand first-class support for explicitly-destroyed types (sometimes referred to as "linear types").
The AnyType,
Movable, and
Copyable traits no longer require that a
type provide a __del__() method that may be called by the compiler
implicitly whenever an owned value is unused. Instead, the
ImplicitlyDestructible
trait should be used in generic code to require that a type is implicitly
destructible.
Explicitly-destroyed types enable Mojo programs to encode powerful invariants in the type system, by modeling a type in such a way that a user is required to take an action "in the future", rather than simply implicitly dropping an instance "on the floor".
Code using T: AnyType can change to use T: ImplicitlyDestructible to
preserve its pre-existing behavior following this change.
Relatedly, the
UnknownDestructibility
trait is now no longer required, as it is equivalent to the new AnyType
behavior.
Mojo no longer supports overloading functions on parameters alone: it will not
try to disambiguate between fn foo[a: Int8](): and fn foo[a: Int32](): for
example. Mojo never fully implemented the previous support in a reliable way,
and removing this simplifies the language. It still supports overloading on
function arguments of course.
The __next_ref__() method in for-each loops has been removed. Now you can
implement the __next__() method of your iterator to return either a value
or a reference. When directly using the collection, Mojo will use the
ref-returning variant, but will allow it to conform to
Iterator for use with generic algorithms (which
use a copied value).
The origin_of(x) operator now returns a value of type Origin instead of an
internal MLIR type, and aliases like ImmutOrigin are now Origin type as
well.
The Origin.cast_from[x] syntax has been replaced with a safe implicit
conversion from any origin to an immutable origin (ImmutOrigin(x)) and an
explicit unsafe conversion (unsafe_origin_mutcast[origin, mut=m]).
The *_ and **_ syntax for explicitly unpacked parameters has been replaced
with a simplified ... syntax. Instead of T[4, 5, *_, **_] you can now use
T[4, 5, ...]. The ... delays binding of both keyword and non-keyword
parameters.
The compiler will now warn on the use of alias keyword and suggest
comptime instead.
The compiler will now warn on unqualified access to struct parameters, for example
@fieldwise_init
struct MyStuff[my_param: Int]:
fn give_me_stuff(self) -> Int:
# Warning: unqualified access to struct parameter 'my_param'; use 'Self.my_param' instead
return my_param
The Mojo compiler generates more clear error messages when diagnosing invalid calls: it mentions the argument name, instead of "argument #4".
The reflection module has been significantly
expanded with new compile-time introspection capabilities. The module has
moved from compile.reflection to a top-level reflection module (update
imports from
from compile.reflection import ... to from reflection import ...).
Internally, the module is now organized into type_info and struct_fields
submodules, though the public API via from reflection import ... remains
unchanged.
Struct field introspection - New APIs for compile-time struct analysis:
struct_field_count[T]() - Returns the number of fields in a structstruct_field_names[T]() - Returns field names as
InlineArray
[StaticString, N]struct_field_types[T]() - Returns a variadic of all field typesstruct_field_index_by_name[T, name]() - Returns field index by namestruct_field_type_by_name[T, name]() - Returns field type wrapped in
ReflectedTypeThese APIs work with both concrete types and generic type parameters:
fn print_fields[T: AnyType]():
comptime names = struct_field_names[T]()
comptime types = struct_field_types[T]()
@parameter
for i in range(struct_field_count[T]()):
print(names[i], get_type_name[types[i]]())
Field access by index - Two new magic functions enable index-based field access without copying:
__struct_field_type_at_index(T, idx) - Returns field type at index__struct_field_ref(idx, ref s) - Returns a reference to the fieldUnlike kgen.struct.extract which copies, __struct_field_ref() returns a
reference, enabling reflection utilities to work with non-copyable types:
fn print_all_fields[T: AnyType](ref s: T):
comptime names = struct_field_names[T]()
@parameter
for i in range(struct_field_count[T]()):
print(names[i], "=", __struct_field_ref(i, s))
Field byte offsets - offset_of[T, name=field_name]() returns the byte
offset of a named field within a struct, enabling no-copy serialization and
other low-level memory operations. The offset is computed at compile time
using the target's data layout, correctly accounting for alignment padding.
This is analogous to C/C++'s offsetof and Rust's offset_of! macro. An
offset_of[T, index=i]() overload is also available to look up by field
index.
from reflection import offset_of
struct Point:
var x: Int # offset 0
var y: Float64 # offset 8 (aligned)
fn main():
comptime x_off = offset_of[Point, name="x"]() # 0
comptime y_off = offset_of[Point, name="y"]() # 8
Type introspection utilities:
is_struct_type[T]() - Returns True if T is a Mojo struct type. Useful
for guarding reflection code that uses struct-specific APIs to avoid
compiler errors on non-struct types (for example, MLIR primitive types). Use
@parameter if since these APIs are evaluated at compile time.
(Issue #5734)
get_base_type_name[T]() - Returns the unqualified name of a parameterized
type's base type. For example, get_base_type_name[List[Int]]() returns
"List". Useful for identifying collection types regardless of element
types. (Issue #5735)
Source location introspection:
SourceLocation - A struct
holding filename, line, and column informationsource_location() -
Returns the location where it's calledcall_location() - Returns the location where the caller was invoked
(requires the caller to be @always_inline)These were previously internal APIs (_SourceLocation, __source_location,
__call_location) in builtin._location. The old module has been removed.
from reflection import source_location, call_location, SourceLocation
fn main():
var loc = source_location()
print(loc) # main.mojo:5:15
@always_inline
fn log_here():
var caller_loc = call_location()
print("Called from:", caller_loc)
Note: These APIs do not work correctly in parameter expressions (comptime contexts return placeholder values).
Trait conformance checking - The conforms_to() builtin now accepts types
from reflection APIs like struct_field_types[T](), enabling conformance
checks on dynamically obtained field types:
@parameter
for i in range(struct_field_count[MyStruct]()):
comptime field_type = struct_field_types[MyStruct]()[i]
@parameter
if conforms_to(field_type, Copyable):
print("Field", i, "is Copyable")
Several traits now have default implementations that use reflection to automatically derive behavior from struct fields. This means simple structs can conform to these traits without implementing any methods - all fields just need to conform to the same trait:
Hashable - Default __hash__()
hashes all fields:
@fieldwise_init
struct Point(Hashable):
var x: Float64
var y: Float64
hash(Point(1.5, 2.7)) # Works automatically
Writable - Default write_to() formats
all fields:
@fieldwise_init
struct Point(Writable):
var x: Float64
var y: Float64
print(Point(1.5, 2.7)) # Point(x=1.5, y=2.7)
Equatable - Default __eq__()
compares all fields:
@fieldwise_init
struct Point(Equatable):
var x: Int
var y: Int
print(Point(1, 2) == Point(1, 2)) # True
Note: The default Equatable performs memberwise equality, which may not be
appropriate for types with floating-point fields (due to NaN semantics).
Override any of these methods for custom behavior.
Removed List variadic initializer.
Statements like:
var x = List[Int32](1, 2, 3)
can be updated to:
var x: List[Int32] = [1, 2, 3]
Expressions like:
var x = foo(List[Float32](1, 2, 3))
can be updated to move the explicit type "hint" around the first element:
var x = foo([Float32(1), 2, 3])
Expressions like:
var data = Span(List[Byte](1, 2, 3))
can be updated to move the explicit element type to the Span:
var data = Span[Byte]([1, 2, 3])
List slicing without a stride now returns a
Span, instead of a List and no longer
allocates memory.
InlineArray no longer
conforms to
ImplicitlyCopyable. Users
must explicitly copy arrays or take references.
IndexList is no longer implicitly
constructible from Int. Previously, the
fill constructor (which broadcasts a single Int to all elements) was marked
@implicit, allowing code like var x: IndexList[3] = 5 which would create
(5, 5, 5). This implicit conversion has been removed to improve type safety.
Use explicit construction instead: IndexList[3](5).
Dict now raises a custom
DictKeyError type on failure,
making lookup failures more efficient to handle.
var d = Dict[String, Int]()
var key = "missing_key"
try:
_ = d[key]
except e:
print(e) # Prints: DictKeyError
New ContiguousSlice and
StridedSlice types were
added to the builtin_slice module to support specialization for slicing
without strides.
Span now conforms to Iterable.
any() and
all() now work over Iterables, which means
they can act over the result of map().
Tuples have been improved:
Tuple.concat().Tuple.reverse().The peekable() function has been added to
iter. This allows users to peek at the next element of an
iterator without advancing it.
String has had its UTF-8
guarantees strengthened.
Span[Byte]) to a String:
String(from_utf8=...): Raises an error if the bytes are invalid UTF-8String(from_utf8_lossy=...): Converts invalid UTF-8 byte sequences
into the (U+FFFD, �) replacement character and does not raise an
error.String(unsafe_from_utf8=...): Unsafely assumes the input bytes are valid
UTF-8 without any checks.append_byte() has been deprecated and has been replaced with
append().The strip(), lstrip(), and rstrip() methods of String and
StringSlice now
support stripping multi-byte unicode codepoints. Additionally lstrip() and
strip() will no longer produce invalid UTF-8 if the "chars" string contains
characters sharing their first byte with a character in the string to be
stripped.
StringLiteral.format()
now emits a compile-time constraint error if the format string is invalid
(instead of a runtime error).
"Hello, {!invalid}".format("world")
# note: constraint failed: Conversion flag "invalid" not recognized.
StringSlice.char_length() has been renamed count_codepoints(). The same
function was added to String and StringLiteral.
Added a CStringSlice as a
type-safe way to interact with nul-terminated c-style strings (const char*).
Removed String.join(*Writable) overload that takes a variadic sequence
of arguments, as it could be ambiguous with the remaining
String.join(Span[Writable]) overload.
Removed the Int.__init__(self, value: StringSlice, base: UInt) constructor.
Users should call atol()
directly.
OwnedDLHandle.get_symbol()
now returns UnsafePointer
[T, MutAnyOrigin] instead of UnsafePointer[T, ImmutAnyOrigin].
The vast majority of symbols loaded from shared libraries are meant to be used
mutably, and it's safer to go from mutable → immutable (via
.as_immutable()) than from immutable → mutable (via
.unsafe_mut_cast[True]()). Users who need
immutable pointers can now simply call .as_immutable() on the result.
The "LegacyUnsafePointer" type has been changed to take its mutability as a first inferred parameter without a default, rather than a later explicit parameter with a default value of true. We recommend moving off of this type as soon as possible, but to roughly emulate the prior behavior, try out:
from memory import LegacyUnsafePointer
comptime UnsafePointer = LegacyUnsafePointer[mut=True, *_, **_]
External origins are now expressed using type level
{Mut,Immut,}ExternalOrigin aliases instead of being spelled like
Origin[True].external, improving consistency with other origin types.
UnsafePointer can now be initialized from a raw memory address using the
unsafe_from_address initializer.
alloc() now has a
debug_assert() ensuring count
is non-negative.
Basic support for explicitly-destroyed types in the standard library is now
available. Explicitly-destroyed types—sometimes referred to as "linear
types"—are types that don't define a __del__() method that the compiler can
call automatically to destroy an instance. Instead, a explicitly-destroyed
type must provide a named method taking deinit self that the programmer is
required to call explicitly whenever an owned instance is no longer used.
The updated AnyType trait can be used in parameters to denote generic code
that supports object instances that can't be implicitly destroyed.
Span, UnsafePointer, Pointer, and
OwnedPointer can point to
explicitly-destroyed types.
UnsafePointer.destroy_pointee_with(), for destroying
explicitly-destroyed types in-place using a function pointer to the type's
destructor.List, InlineArray,
Optional,
Variant,
VariadicListMem, and
VariadicPack can now contain
explicitly-destroyed types.
Variant.take() now takes deinit self instead of mut self.Variant.destroy_with() for destroying an explicitly-destroyed type
in-place by passing in the type's destructor function.*args language syntax for arguments now supports
explicitly-destroyed types.Iterator.Element no longer requires ImplicitlyDestructible.UnsafeMaybeUninitialized
can now contain explicitly-destroyed types.Using a new 'unconditional conformances' technique leveraging conforms_to()
and trait_downcast() to perform
"late" element type conformance checking, some standard library types are now
able to conform to traits that they could not previously:
List, Dict, Set,
Deque, InlineArray, and
LinkedList now conform to
Writable, Stringable, and
Representable. List also
conforms to Equatable.Pointer, ArcPointer, and
OwnedPointer now conform to Writable.Iterator, Tuple, Variant, and Optional no longer require their
element types to be Copyable.The Iterator trait and for-each loop have removed the __has_next__()
method and now use a __next__() method that raises
StopIteration. This follows Python precedent
better, is more convenient to implement, and can be a minor performance win
in some cases.
The ImplicitlyBoolable trait has been removed. This trait enabled types to
implicitly convert to Bool. This behavior was
rarely used, and could lead to subtle bugs, for example mistakenly passing
types like Int or UnsafePointer to an argument expecting a Bool would
silently compile successfully.
The Error type no longer conforms to
Boolable or
Defaultable. Errors must now be
constructed with meaningful context, and optionality should be expressed
through Optional[Error] rather than treating errors as boolean values.
The Copyable trait now refines the Movable trait. This means that structs
and generic algorithms that already require Copyable don't need to also
mention they require Movable.
The EqualityComparable trait has been deprecated in favor of Equatable,
which has identical functionality.
We have removed
Identifiable from enum-like
types (such as DType and
AddressSpace). This change is
related to the idea that Identifiable is for comparing memory addresses.
The ConvertibleFromPython trait and associated initializers now have a
required keyword argument. Before: Int(pyObj). After: Int(py=pyObj). This
avoids ambiguities in cases where either multiple overloads could apply, or
where implicit conversions to PythonObject could mask that a Python
operation was happening.
PythonObject now supports
implicit conversion from None, allowing more natural Python-like code:
var obj: PythonObject = None # Now works without explicit PythonObject(None)
fn returns_none() -> PythonObject:
return None # Implicit conversion
Basic file I/O operations in the io module are now implemented natively in
Mojo using direct libc system calls (open(), close(), read(),
write(), lseek()). The FileHandle type
no longer depends on CompilerRT functions, providing better performance and
transparency. Error handling now includes errno-based messages for improved
diagnostics.
The os.process submodule has been added with utilities to spawn and
wait on processes. These use posix_spawn() and do not go through the
system shell.
Various OS wrapper functions now include the value of errno in the raised
error message.
The os module now exposes a link() function,
wrapping the unix link(2) system call.
The os module now exposes a symlink()
function, wrapping the unix symlink(2) syscall.
Layout no longer conforms to
ImplicitlyCopyable. The
motivation for this change is that it was easy to accidentally materialize a
Layout at runtime
using methods such as Layout.size(). There are a few downstream changes
users will have to adapt to with this change. Below are some common patterns
which will help with this transition:
from layout import Layout
fn foo(a: Layout) -> Layout:
return a.copy() # `a` needs to be explicitly copied.
fn bar(var a: Layout) -> Layout:
return a^ # If a is taken by value, one can use the transfer operator.
fn baz():
comptime a = Layout.row_major(4, 4)
# `a` needs to be materialized because `foo` returns a type that
# is not ImplicitlyCopyable (`Layout`).
var b = foo(materialize[a]())
# `bar` moves `b` by value, but `foo` also takes `b` by reference,
# so we need to explicitly copy.
_ = bar(b.copy())
_ = foo(b)
# Since we are no longer using `b`, it's fine to take it by value here.
_ = bar(b^)
# Since `Layout.size()` returns an `Int`, we can use a `comptime`
# expression to compute the return value without materializing `a`.
for i in range(comptime (a.size())):
...
DeviceContext.enqueue_function_checked() and
DeviceStream.enqueue_function_checked() have been renamed to
enqueue_function(). Similarly, DeviceContext.compile_function_checked()
has been renamed to compile_function().
DeviceContext.enqueue_function() and
DeviceContext.enqueue_function_experimental() now automatically infer
func_attribute to
FuncAttribute.MAX_DYNAMIC_SHARED_SIZE_BYTES(shared_mem_bytes) when
shared_mem_bytes is specified but func_attribute is not, for NVIDIA GPUs
with allocations > 48KB. This eliminates the need to specify the same shared
memory size twice in many cases, reducing boilerplate and preventing
mismatched values. On AMD GPUs or for allocations ≤ 48KB, explicit
func_attribute values should be provided when needed.
The inlined_assembly() function is now publicly exported from the sys
module, allowing users to embed raw assembly instructions directly into Mojo
code.
This provides fine-grained control over hardware operations using LLVM-style
inline assembly syntax. Example:
from sys import inlined_assembly
# Convert bfloat16 to float32 on NVIDIA GPU using PTX assembly.
var result = inlined_assembly[
"cvt.f32.bf16 $0, $1;",
Float32,
constraints="=f,h",
has_side_effect=False,
](my_bf16_as_int16)
Writer has been reworked to support only UTF-8
data instead of arbitrary Byte sequences. The write_bytes() method has
been replaced with write_string().
String's write_bytes() method has also been
deprecated, and its initializer __init__(out self, *, bytes: Span[Byte])
has had its keyword argument renamed to unsafe_from_utf8. This brings it
more in line with the existing StringSlice constructors and explicitly
states that construction from arbitrary bytes is inherently unsafe.Writer and Writable have been moved into a new format module and out of
io. These traits are not directly related to binary i/o, but are rather
closely tied to type/value string formatting.
The Writable trait now supports debug formatting through an optional
write_repr_to() method, called by repr()
and the {!r} format specifier.
Additionally, repr() and string formatting methods (.format() on String,
StringSlice, and StringLiteral) now accept Writable types, enabling
efficient formatting without intermediate string allocations. To preserve
existing behavior, types implementing both Stringable & Representable and
Writable will continue using Stringable & Representable methods; only
types implementing Writable alone will use the new code paths.
Counter now conforms to Writable,
Stringable, and Representable.
black_box() has been added to the
benchmark utilities as a way to prevent the compiler from aggressively
optimizing out values. Similar to
keep(), however, it returns its
argument.
The UInt struct has been replaced by a new
UInt type alias to Scalar[DType.uint]. This is a major change that enables
more powerful
generic programming by abstracting over unsigned SIMD data dtypes of machine
word size.
This change will likely break code that relies on implicit conversions to/from
UInt and Int/SIMD. The SIMD type is also slightly less foldable at
compile time, which can cause some code in where clauses, comptime
expressions, and other code in parametric contexts to now fail or crash. These
shortcomings will be addressed in subsequent patches as needed.
Implicit conversion between Int and UInt has been removed.
The random module now uses a pure Mojo implementation
based on the Philox algorithm (via an internal wrapper), replacing the
previous CompilerRT C++ dependency. The Philox algorithm provides excellent
statistical quality, works on both CPU and GPU, and makes random number
generation fully transparent and source-available. Note that this changes the
random number sequence for a given seed value, which may affect tests or code
relying on reproducible sequences.
StringableRaising has been deprecated and its usages in the stdlib have
been removed.
Variadic now has zip_types(), zip_values(), and slice_types().
The Mojo compiler now supports the -Werror flag, which treats all warnings
as compilation errors. This is useful for enforcing stricter code quality
standards, particularly in CI/CD pipelines. The flag works with the Mojo
compiler tools (mojo run, mojo build, mojo package, mojo doc).
When used with --disable-warnings, warnings are promoted to errors first,
so the errors are not suppressed.
-Wno-error flag disables treating warnings as errors.
When both flags are specified, the last one wins.Specifying CUDA architectures with --target-accelerator now expects a sm
version string rather than just a compute capability. For example,
--target-accelerator=nvidia:80 should be changed to
--target-accelerator=nvidia:sm_80. If an incorrect format is used for the
version, the compiler will default to the lowest supported sm version.
The Mojo LSP server now debounces document updates to reduce CPU usage during rapid typing. Previously, every keystroke triggered a full document parse; now updates are coalesced with a 150ms delay, reducing parse frequency by 10-50x during active editing.
The Mojo compiler now "diffs" very long types in error messages to explain what is going on in an easier to understand way.
Elaboration error printing with different levels of verbosity
offers control on how parameter values are displayed as part of
elaboration errors when function instantiation fails.
--elaboration-error-verbose=value now takes a value, where:
no-params means don't display any concrete parameter values.
This is helpful to collapse recursion-related error messages
into shorter blobs.simple-params means display concretized parameter values for simple types,
including numeric types and strings, in a user-friendly format
(default value).all-params means show all concrete parameter values.
This is for advanced programmers who don't mind reading
MLIR attributes but want more visibility of parameter values.--elaboration-max-depth is added to control maximum elaborator
instantiation depth. This (unsigned) value helps to detect compile time
recursion. The default is std::numeric_limits<unsigned>::max().
Docstring validation with --validate-doc-strings now emits an error when an
fn function is declared to raise an error (raises) but it's missing a
Raises docstring
(previously it emitted only a warning). Because Mojo automatically treats all
def functions as
raising functions,
we don't enforce Raises docs for def functions (to avoid noisy false
positives).
Docstring validation now includes comptime aliases. The
--diagnose-missing-doc-strings flag now checks that public aliases have
properly formatted docstrings (summary ends with period, starts with capital
letter). Parametric aliases are also checked for proper Parameters:
sections.
The --validate-doc-strings flag has been deprecated for mojo doc and
removed from other tools (mojo build, mojo run, mojo package). Use
-Werror instead to treat warnings as errors.
The Mojo compiler now supports the -Xlinker flag to pass options on
directly to the linker, for example:
mojo build -Xlinker -lfoo main.mojo
Note: this option only has an effect with mojo build. With mojo run, the
arguments are ignored and a warning is issued.
The Mojo compiler now supports the --experimental-export-fixit flag for
mojo build, mojo run, and mojo package. This flag exports fix-its to a
YAML file compatible with clang-apply-replacements, instead of applying them
directly. This is useful for integrating Mojo's fix-it suggestions into
external tooling workflows. The flag is mutually exclusive with
--experimental-fixit (which applies fix-its directly).
The Mojo Debugger mojo break-on-raise feature now works correctly with
multiple targets in a debugger instance. The setting is per-target.
Changes described in this section are experimental and may be changed, replaced, or removed in future releases.
Mojo now supports compile-time trait conformance check (via conforms_to())
and downcast (via trait_downcast()). This allows users to implement features
like static dispatching based on trait conformance. For example:
fn maybe_print[T : AnyType](maybe_printable : T):
@parameter
if conforms_to(T, Writable):
print(trait_downcast[Writable](maybe_printable))
else:
print("[UNPRINTABLE]")
Added support for DType expressions in
where clauses:
fn foo[dt: DType]() -> Int where dt == DType.int32:
return 42
Currently, the following expressions are supported:
is_signed(), is_unsigned(), is_numeric(), is_integral(),
is_floating_point(), is_float8(), is_half_float()Added support for SIMD expressions in where
clauses:
fn foo[dt: DType, x: Int]() -> Int where SIMD[dt, 4](x) + 2 > SIMD[dt, 4](0):
return 42
Currently, the following expressions are supported:
Int and
IntLiteralThe following deprecated GPU compatibility modules have been removed:
gpu.id - Use from gpu import block_idx, thread_idx, ... insteadgpu.block - Use from gpu.primitives.block import ... insteadgpu.warp - Use from gpu.primitives.warp import ... insteadgpu.cluster - Use from gpu.primitives.cluster import ... insteadgpu.grid_controls - Use from gpu.primitives.grid_controls import ...
insteadgpu.mma - Use from gpu.compute.mma import ... insteadgpu.mma_operand_descriptor - Use
from gpu.compute.mma_operand_descriptor import ... insteadgpu.mma_util - Use from gpu.compute.mma_util import ... insteadgpu.mma_sm100 - Use from gpu.compute.arch.mma_nvidia_sm100 import ...
insteadgpu.semaphore - Use from gpu.sync.semaphore import ... insteadgpu.tcgen05 - Use from gpu.compute.arch.tcgen05 import ... insteadThe DeviceContext enqueue_function_unchecked() and
compile_function_unchecked() have been removed. Please migrate the code to
use enqueue_function() and compile_function().
NDBuffer has been removed. Use
LayoutTensor instead.
The UnsafePointer.offset() method is now deprecated. Use pointer arithmetic
instead:
# Before
new_ptr = ptr.offset(n)
# After
new_ptr = ptr + n
Int, NoneType, and
Origin.get_type_name() now handles types with constructor calls in their
parameters (like A[B(True)]) when extracted via struct_field_types().get_type_name() now handles nested parametric types from
struct_field_types().struct_field_type_by_name() now works correctly when using
ReflectedType.T as a type annotation.rebind() and rebind_var() now accept downcasted types from
struct_field_types(), allowing patterns like
rebind_var[types[i]](downcast[types[i], Trait]()^).time.sleep() now works correctly for durations
longer than 1 millisecond on NVIDIA GPUs. Previously, sleep durations were
silently capped at 1ms due to a hardware limitation in the underlying
nanosleep intrinsic. AMD GPUs now have basic sleep support using the
s_sleep instruction, which is sufficient for spin-wait backoff operations
though it doesn't provide accurate wall-clock timing. Additionally,
global_perf_counter_ns() is now exported from the time package for GPU
code that needs nanosecond-resolution timing.ref.Codepoint.unsafe_decode_utf8_codepoint()
no longer returns Codepoint(0) (NUL) when passed an empty span. Instead, a
debug_assert() now enforces the requirement that the input span be
non-empty, consistent with the function's existing safety contract.Deque shrink reallocation incorrectly
handled empty deque with capacity > min_capacity.Special thanks to our community contributors:
Alex Maldonado (@aalexmmaldonado), Bernhard Merkle (@bmerkle), Brian Grenier (@bgreni), Christoph Schlumpf (@christoph-schlumpf), Duba Sirisha (@SirishaDuba), Ethan Wu (@YichengDWu), Gunasekar (@sdgunaa), Hristo (Izo) G. (@izo0x90), Johannes Laute (@jaidmin), Jordan Rinder (@jrinder42), josiahls (@josiahls), Krish Gupta (@KrxGu), Magi Sharma J (@magi8101), Manuel Saelices (@msaelices), martinvuyk (@martinvuyk), Richard Johnsson (@jmikaelr), Ritesh Goru (@BlackWingedKing), Ross Campbell (@RossCampbellDev), RWayne93 (@RWayne93), soraros (@soraros), Sören Brunk (@sbrunk), turakz (@turakz), Valentin Erokhin (@saviorand), YeonguChoe (@YeonguChoe)
]]>A new, improved
UnsafePointer type has
been added, and the old version renamed to
LegacyUnsafePointer.
The new version fixes several issues with the old LegacyUnsafePointer.
LegacyUnsafePointer had constructors that allowed unsafe implicit
mutability and origin casts, making it easy to make unsafe changes by
accident. The new UnsafePointer eliminates these.UnsafePointer now has an inferred mutability parameter,
simplifying the API.UnsafePointer does not have a default value for its origin parameter, so
it must be explicitly specified or unbound. LegacyUnsafePointer defaults
to MutAnyOrigin, which results in the lifetimes of many values being
extended needlessly.For more information, see Pointer and memory changes.
Many enhancements to compile-time errors, including suppressing extraneous messages and preserving more human-readable display for many aliases and parameters. For details, see Tooling changes.
Added a new document on GPU block and warp operations and synchronization.
Mojo now supports the comptime keyword as a synonym for alias. The
comptime keyword can be used interchangeably with alias for compile-time
declarations. Both keywords are fully supported and produce identical
behavior. For example:
comptime x = 5 # New preferred syntax
alias y = 10 # Still fully supported
comptime MyType[T: AnyType] = T # Works with parametric declarations
Note: Future updates will migrate error messages and internal terminology to
use "comptime". The alias keyword will remain supported for backward
compatibility for now.
Mojo now supports unpacking an alias/comptime tuple with a single statement when it is not inside a struct or trait. For example:
comptime i, f = (1, 3.0)
comptime q, v = divmod(4, 5)
Issue #3925: Mojo now allows methods to be overloaded based on "owned" vs "by-ref" argument conventions, selecting the owned overload when given an owned value, and selecting the by-ref version otherwise. This allows somewhat more efficient algorithms, e.g. consuming vs borrowing iterators:
struct MyCollection:
fn __iter__(var self) -> Self.ConsumingIterator: ...
fn __iter__(self) -> Self.BorrowingIterator: ...
Collection literals now have a default type. For example, you can now bind
[1,2,3] to T in a call to a function defined as
fn zip[T: Iterable](impl:T) because it will default to the standard
library's List type.
Mojo now has a __functions_in_module() experimental intrinsic that allows
reflection over the functions declared in the module where it is called. For
example:
fn foo(): pass
def bar(x: Int): pass
def main():
alias funcs = __functions_in_module()
# equivalent to:
alias same_funcs = Tuple(foo, bar)
The intrinsic is currently limited for use from within the main() function.
For an example of using __functions_in_module() in a test suite, see
Running tests with TestSuite
The @implicit decorator now accepts an optional deprecated keyword
argument. This can be used to phase out implicit conversions instead of just
removing the decorator (which can result in another, unintended implicit
conversion path). For example, the compiler now warns about the following:
struct MyStuff:
@implicit(deprecated=True)
fn __init__(out self, value: Int):
pass
fn deprecated_implicit_conversion():
# warning: deprecated implicit conversion from 'IntLiteral[1]' to 'MyStuff'
_: MyStuff = 1
_ = MyStuff(1) # this is okay, because the conversion is already explicit.
The @deprecated decorator can now take a target symbol with the use
keyword argument. This is mutually exclusive with the existing positional
string argument. A deprecation warning will be automatically generated.
@deprecated(use=new)
fn old():
pass
fn new():
pass
fn main():
old() # 'old' is deprecated, use 'new' instead
In struct instances that declare a parametric __call__() method, but not
one of the subscript methods (__getitem__(), __setitem__(), or
__getattr__()), the __call__() method can now be invoked with parameters:
struct Callable:
fn __init__(out self):
pass
fn __call__[x: Int](self, y: Int) -> Int:
return x + y
fn main():
var c = Callable()
print(c[1](2)) # 3
Previously you would have needed to explicitly look up __call__():
print(c.__call__[1](2))
Added DType.float4_e2m1fn as the 4bit float e2m1 format. This
Float4_e2m1 type is defined by the
Open Compute MX Specification.
deinit methods may now transfer all of self to another deinit method.
Mojo now uses system allocators in programs built with
mojo build --sanitize address. This means ASan can see Mojo heap allocations
and should now be able to detect many more heap memory errors.
The __type_of() magic function has been renamed to type_of(). Using the
old spelling will yield an error. Similarly, __origin_of() has been renamed
to origin_of().
An expression like (Int, Float64) is no longer syntax sugar for a tuple
types like Tuple[Int, Float64].
UnsafePointer has been renamed to LegacyUnsafePointer and a new
UnsafePointer has
taken its place.
Similarly, OpaquePointer has been renamed to LegacyOpaquePointer and a new
OpaquePointer has taken
its place. The primary difference is the ordering of parameters, which now
looks like this:
struct UnsafePointer[
mut: Bool, //, # Inferred mutability
type: AnyType,
origin: Origin[mut], # Non-defaulted origin
*,
address_space: AddressSpace = AddressSpace.GENERIC,
]
alias OpaquePointer[
mut: Bool, //, # Inferred mutability
origin: Origin[mut], # Non-defaulted origin
*,
address_space: AddressSpace = AddressSpace.GENERIC,
] = UnsafePointer[NoneType, origin, address_space=address_space]
Its implicit constructors now no longer allow for unsafe casting between
pointers with different mutability and origin values. Code will need to update
to the new UnsafePointer, however, in the interim, users can
find-and-replace their current usages of UnsafePointer and rename them to
LegacyUnsafePointer. Another option is users can add the following import
statement to the beginning of any files relying on the old pointer type:
from memory import LegacyUnsafePointer as UnsafePointer, **_]
# and/or if you use OpaquePointer
from memory import LegacyOpaquePointer as OpaquePointer
Users can also use the as_legacy_pointer() and as_unsafe_pointer()
conversion methods to convert between the two pointer types during this
migration period.
Note: LegacyUnsafePointer and LegacyOpaquePointer will eventually be
deprecated and removed in a future version of Mojo.
There are a few new helpful type aliases for UnsafePointer:
MutUnsafePointerImmutUnsafePointerMutOpaquePointerImmutOpaquePointerLastly, alloc() has been moved
from a static method on UnsafePointer to a free standing alloc() function.
Therefore, code that was written as:
var ptr = UnsafePointer[Int].alloc(3)
Must be changed to:
var ptr = alloc[Int](3)
For more details on migrating to the new UnsafePointer, see the migration
guide provided in the
Added a swap_pointees() function to UnsafePointer as an alternative to
swap() when the pointers may potentially alias each other.
origin_cast() for
LayoutTensor,
NDBuffer and UnsafePointer has
been deprecated and removed. LayoutTensor and NDBuffer now support a safer
as_any_origin() origin casting method. UnsafePointer has the same safe
alternative and in addition, it has a safe as_immutable()
casting function and explicitly unsafe unsafe_mut_cast() and
unsafe_origin_cast() casting methods.
The empty origin has been renamed to external. This origin represents a
value that's not tracked by the Mojo lifetime checker. Newly-allocated memory
from alloc() is returned with the origin MutOrigin.external.
Renamed MutableOrigin to MutOrigin and ImmutableOrigin to ImmutOrigin.
Renamed MutableAnyOrigin to MutAnyOrigin and ImmutableAnyOrigin to
ImmutAnyOrigin.
memcpy() and
parallel_memcpy() without
keyword arguments are deprecated.
Span and
StringSlice
constructors now accept Int for length parameters instead of UInt. This
change makes these types more ergonomic to use with integer literals and other
Int-based APIs.
Added Span.binary_search_by() which allows binary searching with a custom
comparator function.
Added unsafe_get(), unsafe_swap_elements() and unsafe_subspan() to
the Span struct.
Optional now conforms to
Iterable and Iterator acting as a collection of size 1 or 0.
New ContiguousSlice
and
StridedSlice
types were added to the builtin_slice module to support specialization for
slicing without strides.
List slicing without a stride now
returns a Span, instead of a List and no longer allocates memory.
Several standard library APIs have been updated to use Int instead of UInt
for improved ergonomics, eliminating the need for explicit casts when using
Int values (the default type for integer literals and loop indices):
BitSet[size: Int] - Changed parameter from UInt to IntBitSet.set(idx: Int), BitSet.clear(idx: Int), BitSet.toggle(idx: Int),
BitSet.test(idx: Int) - Changed from UInt to IntString(unsafe_uninit_length: Int) - Changed from UInt to IntString.capacity() -> Int - Changed return type from UInt to IntString.reserve(new_capacity: Int) - Changed from UInt to IntList(length: Int, fill: T) - Changed from UInt to IntCodepoint.unsafe_write_utf8() -> Int - Changed return type from UInt to
IntCodepoint.utf8_byte_length() -> Int - Changed return type from UInt to
IntAdded repeat() function to the
itertools module that creates an iterator which repeats an element a
specified number of times. Unlike Python's itertools.repeat(), infinite
iteration is not currently supported - the times parameter is required.
Example usage:
from itertools import repeat
for val in repeat(42, times=3):
print(val) # Prints: 42, 42, 42
Tuples now support comparison operations if the element types are also
comparable. For example, one can now write (1, "a") == (1, "a") or
(1, "a") < (1, "b").
Codepoint now conforms to
Comparable adding __le__(),
__lt__(), __ge__(), and __gt__() implementations.
The deprecated DType.index is now removed in favor of the
DType.int.
Added DType.float4_e2m1fn as the 4bit float e2m1 format. This
Float4_e2m1 type is defined by the
Open Compute MX Specification.
math.isqrt() has been renamed to rsqrt()
since it performs reciprocal square root functionality.
The math package now has a Mojo native
implementation of acos(), asin(), cbrt(), and erfc().
SIMD now implements the
DivModable trait.
Implicit conversions between Int and UInt are now deprecated.
The @implicit decorator on Int.__init__(UInt) and UInt.__init__(Int)
will be removed in a future version of Mojo. Code that currently performs
implicit conversions between Int and UInt will issue a deprecation
warning, and should be updated to explicitly read Int(uint_val) or
UInt(int_val) respectively.
The ImplicitlyIntable trait has been removed. Types implementing this trait
could be implicitly converted to Int.
Bool was the only Mojo standard library type to implement
ImplicitlyIntable. Conversions from Bool to Int can now be performed
explicitly, using Int(bool-val) (via the remaining Intable trait, which
only supports explicit conversions).
Added support for NVIDIA GeForce GTX 970.
gpu.sync.syncwarp() now supports
Apple GPUs via SIMDGROUP barrier implementation. On Apple GPUs, this
provides execution synchronization for all active lanes using a SIMDGROUP
barrier with no memory fence. For threadgroup memory ordering, use
barrier() instead. Note that lane
masks are not supported on Apple GPUs, so the mask argument is ignored.
gpu.primitives.warp now supports Apple
GPUs with native SIMD-group shuffle operations. This enables shuffle_idx(),
shuffle_up(), shuffle_down(), and shuffle_xor() on Apple hardware by
mapping Metal simd_shuffle* intrinsics to AIR
(llvm.air.simd_shuffle[_up/_down/_xor]) instructions, achieving feature
parity with NVIDIA and AMD backends.
gpu.intrinsics.store_release()
and
gpu.intrinsics.load_acquire()
now support Apple silicon GPUs, expanding support for proper memory
synchronization on these devices.
The gpu package has been reorganized into logical
subdirectories for better code organization:
gpu/primitives/ - Low-level GPU execution primitives (warp, block,
cluster, id, grid_controls)gpu/memory/ - Memory operations (async_copy, TMA, address spaces)gpu/sync/ - Synchronization primitives (barriers, semaphores)gpu/compute/ - Compute operations (mma, tensor cores, tcgen05)Backward compatibility: All existing imports continue to work unchanged.
Deprecated import paths (gpu.id, gpu.mma, gpu.cluster,
gpu.grid_controls, gpu.warp, gpu.semaphore, gpu.mma_sm100,
gpu.tcgen05, gpu.mma_util, gpu.mma_operand_descriptor, and
gpu.tensor_ops) are preserved as re-export wrappers with deprecation
notices. Users can migrate to the new recommended import patterns at their
own pace:
# Old (deprecated but still works):
from gpu.id import block_idx, thread_idx
from gpu.mma import mma
from gpu.mma_sm100 import UMMAKind
from gpu.tcgen05 import tcgen05_alloc
from gpu.semaphore import Semaphore
from gpu.cluster import cluster_sync
# New (recommended):
from gpu import block_idx, thread_idx, cluster_sync
from gpu.compute.mma import mma
from gpu.compute.mma_sm100 import UMMAKind
from gpu.compute.tcgen05 import tcgen05_alloc
from gpu.sync.semaphore import Semaphore
The _GPUAddressSpace type has been removed and consolidated into
AddressSpace. GPU-specific
address space constants (GLOBAL, SHARED, CONSTANT, LOCAL,
SHARED_CLUSTER) are now available as aliases on the unified AddressSpace
type. The GPUAddressSpace alias has also been removed in favor of using
AddressSpace directly. Since AddressSpace is part of the prelude, it no
longer needs to be explicitly imported in most code.
TMA (Tensor Memory Accelerator) types have been moved to a dedicated module.
The types TMADescriptor, TensorMapSwizzle, TensorMapDataType,
TensorMapInterleave, TensorMapL2Promotion, TensorMapFloatOOBFill, and
the functions create_tma_descriptor() and prefetch_tma_descriptor() are
now available from gpu.host.nvidia.tma
instead of gpu.host._nvidia_cuda.
assert_equal() now displays
colored character-by-character diffs when string comparisons fail, making it
easier to spot differences. Differing characters are highlighted in red for
the left string and green for the right string.
The mojo test command has been removed. The recommended testing strategy is
to define test functions, call them explicitly from main() (or use the new
TestSuite framework), and run with mojo run.
TestSuite now can generate test
reports with .generate_report(). Also, TestReport and TestSuiteReport
structs were added.
TestSuite now allows explicitly skipping registered tests using the
TestSuite.skip() method.
TestSuite now allows basic control from CLI arguments. Tests can be skipped
from the CLI by passing test function names after a --skip flag, e.g.
mojo run test_my_stuff.mojo --skip test_currently_failing test_also_failing
Similarly, the --only flag enables the specification of an allowlist, e.g.
the following will skip any other registered test cases:
mojo run test_my_stuff.mojo --only test_only_this test_this_as_well
The --skip-all flag will skip all registered test cases in the suite. Note
that --only respects skipped tests, i.e. it does not run tests that are
skipped using TestSuite.skip().
Added os.isatty() function to check whether a
file descriptor refers to a terminal. This function accepts an Int file
descriptor. If you have a
FileDescriptor object,
use its isatty() method instead.
Added
sys.compile.SanitizeAddress
providing a way for Mojo code to detect --sanitize address at compile time.
DLHandle is no longer part of the public API. To access a dynamically-linked
library from Mojo, use OwnedDLHandle
instead. The new type provides RAII-based automatic resource management for
dynamically-linked libraries. DLHandle has been renamed to _DLHandle and
remains available internally for use by the standard library.
Optimized float-to-string formatting performance by eliminating unnecessary
stack allocations. Internal lookup tables used for float formatting
(cache_f32 and cache_f64) are now stored as global constants instead of
being materialized on the stack for each conversion. This reduces stack
overhead by ~10KB for Float64 and ~600 bytes for Float32 operations,
improving performance for all float formatting operations including print(),
string interpolation, and str() conversions.
Optimized number parsing performance by eliminating stack allocations for
large lookup tables. Internal lookup tables used for number parsing
(powers_of_5_table and POWERS_OF_10) are now stored as global constants
using the global_constant
function instead of being materialized on the stack for each parsing
operation. This reduces stack overhead by ~10.6KB for number parsing
operations, improving performance for string-to-number conversions including
atof() and related float parsing operations.
The Hasher trait's
_update_with_bytes() method now takes Span[Byte] instead of
UnsafePointer[UInt8] and a separate length parameter. This change applies to
all hasher implementations including AHasher and Fnv1a.
The Philox random number generator (Random and NormalRandom) has been
moved from gpu.random to random.philox.
These types now work on both CPU and GPU. Import them using
from random import Random, NormalRandom or
from random.philox import Random, NormalRandom.
Error and warning messages now preserve comptime/alias names in many cases,
to prevent extremely long type names for complex types. The compiler will
expand these when necessary to understand the type based on a simple
heuristic, for example:
struct Dep[T: AnyType, v: T]: pass
alias MyDep[T: AnyType, v: T] = Dep[T, v]
alias MyDepGetAlias0 = MyDep.hello
produces:
$ mojo t.mojo
t.mojo:10:29: error: 'MyDep' needs more parameters bound before accessing attributes
alias MyDepGetAlias0 = MyDep.hello
^
t.mojo:10:29: note: 'MyDep' is aka 'alias[T: AnyType, v: T] Dep[T, v]'
Please file issues in cases where more information needs to be exposed.
Error messages now preserve symbolic calls to always_inline("builtin")
functions rather than inlining them into the error message.
This release includes a number of improvements to elaboration errors. The elaborator is the compiler pass where final parameter values are determined and code is transformed from parametric to concrete. Common errors from elaboration include "function instantiation failed" and "call expansion failed" messages, when it's determined that the actual parameter values don't match any viable function overload.
The elaborator also checks constraints (defined using the
constrained() function), so
constraint failures are generated during this pass.
Elaboration errors now report the full call instantiation failure path. For this Mojo file:
fn fn1[T: ImplicitlyCopyable, //] (a: T):
constrained[False]()
fn fn2[T: ImplicitlyCopyable, //] (a: T):
return fn1(a)
fn main():
fn2(1)
Now the error prints the path of main -> fn2 -> fn1 -> constrained[False]
instead of just constrained[False].
Elaboration errors now print out trivial parameter values with call expansion failures. For this simple Mojo program:
fn fn1[a: Int, b: Int]():
constrained[a < b]()
fn fn2[a: Int, b: Int]():
fn1[a, b]()
fn main():
fn2[4, 2]()
Now the error message shows parameter value(s): ("a": 4, "b": 2):
test.mojo:6:14: note: call expansion failed with parameter value(s): ("a": 4, "b": 2)
fn1[a, b]()
Only string and numerical values are printed out by default now, other
values are shown as .... Use --elaboration-error-verbose to show all
parameter values.
Elaboration error messages related to the prelude are omitted by default.
The prelude is the set of APIs exported from std/builtin/_startup.mojo.
These APIs persist in all call expansion paths but are rarely the source of
reported errors. These APIs are now omitted by default to de-clutter
elaboration errors.
Use --elaboration-error-include-prelude to include prelude.
By default (without prelude):
test.mojo:43:4: error: function instantiation failed
fn main():
^
test.mojo:45:12: note: call expansion failed
my_func()
...
With prelude:
oss/modular/mojo/stdlib/std/builtin/_startup.mojo:119:4: error: function instantiation failed
fn __mojo_main_prototype(
^
oss/modular/mojo/stdlib/std/builtin/_startup.mojo:119:4: note: call expansion failed with parameter value(s): (...)
oss/modular/mojo/stdlib/std/builtin/_startup.mojo:42:4: note: function instantiation failed
fn __wrap_and_execute_main[
^
oss/modular/mojo/stdlib/std/builtin/_startup.mojo:68:14: note: call expansion failed
main_func()
^
test.mojo:43:4: note: function instantiation failed
fn main():
^
test:45:12: note: call expansion failed
my_func()
...
An --elaboration-error-limit option has been added to the mojo run and
mojo build commands. This option sets a limit to the number of elaboration
errors that get printed. The default value is 20. To change the limit, use
--elaboration-error-limit=limit, where a limit of
0 means unlimited.
--help-hidden option has been added to all Mojo CLI commands to show hidden
options.
mojo debug now rejects unknown options between debug and the target.
The Mojo language server will now report more coherent code actions.
The mojo CLI now has an --experimental-fixit flag that automatically
applies FixIt hints emitted by the parser. This feature is highly
experimental, and users should ensure they back up their files (or check them
into source control) before using it.
mojo test has been deprecated and removed as described in the
deprecation proposal.
For more information, see the Testing section.
LayoutTensorBuild type has been removed. Use LayoutTensor with parameters
directly instead.
The following traits have been removed: LessThanComparable,
GreaterThanComparable, LessThanOrEqualComparable,
GreaterThanOrEqualComparable. It is extremely rare that a type would only
implement one of these, so one can just use Comparable instead.
All telemetry-related code has been removed from the Mojo compiler. This should eliminate the source of some hangs and misbehavior on poor internet connections.
Issue #5111: The
math.cos() and math.sin() function can now be evaluated at compile time.
Fixed IntTuple.value(i) method returning incorrect values when elements are
stored as nested single-element tuples. Previously, calling
Layout.row_major(M, N).stride.value(i) would return negative offset values
(e.g., -65536, -65537) instead of the actual stride values. This affected any
code that accessed layout stride or shape values using the value() method.
Fixed LayoutTensor.shape[idx]() method returning incorrect values for nested
layouts. The bug occurred when accessing shape dimensions of tensors with
nested layouts like ((32, 2), (32, 4)), where the method would return
garbage values instead of the correct product (e.g., 64).
Fixed LayoutTensor element-wise arithmetic operations (+, -, *, /)
between tensors with different memory layouts. Previously, operations like
a.transpose() - b would produce incorrect results when the operands had
different layouts, because the same layout index was incorrectly used for both
operands. This now correctly computes separate indices for each tensor based
on its layout.
Fixed LayoutTensor.shape[idx]() method returning incorrect values for nested
layouts. The bug occurred when accessing shape dimensions of tensors with
nested layouts like ((32, 2), (32, 4)), where the method would return
garbage values instead of the correct product (e.g., 64).
Fixed arange() function in layout._fillers to properly handle nested
layout structures. Previously, the function would fail when filling
tensors with nested layouts like
Layout(IntTuple(IntTuple(16, 8), IntTuple(32, 2)), ...) because it
attempted to extract shape values from nested tuples incorrectly.
Issue #5479: Mojo crashes
when compiling standalone __del__ function without struct context.
Issue #5500: Added
comprehensive documentation to gpu/host/info.mojo explaining GPU target
configuration and LLVM data layout strings. The documentation now includes
detailed explanations of all MLIR target components, vendor-specific patterns
for NVIDIA/AMD/Apple GPUs, step-by-step guides for adding new GPU
architectures, and practical methods for obtaining data layout strings.
Issue #5492: Fixed
FileHandle "rw" mode unexpectedly truncating file contents. Opening a file
with open(path, "rw") now correctly preserves existing file content and
allows both reading and writing, similar to Python's "r+" mode. Previously,
"rw" mode would immediately truncate the file, making it impossible to read
existing content and causing potential data loss.
Issue #3849: Added support
for append mode ("a") when opening files. The open() function now accepts
"a" as a valid mode, which opens a file for appending. Content written to a
file opened in append mode is added to the end of the file without truncating
existing content. If the file doesn't exist, it will be created.
Issue #3208: Fixed
FileHandle raising "unable to remove existing file" error when opening a
FIFO (named pipe) in write mode. Opening special files like FIFOs, devices,
and sockets with open(path, "w") now works correctly. Previously, write
mode would attempt to remove the existing file before opening it, which
failed for special files that should not be removed.
Issue #5142: The
sys.intrinsics.compressed_store function now includes a debug_assert to
catch null pointer usage, providing a clear error message instead of crashing
with a segmentation fault.
The sys.intrinsics.strided_load(), sys.intrinsics.strided_store(),
sys.intrinsics.masked_load(), and sys.intrinsics.masked_store() functions
now include a debug_assert() to catch null pointer usage, providing a clear
error message instead of crashing with a segmentation fault.
The logger package now prints its levels in color.
Throwing deinit methods now understand that self is deinitialized in error
paths, avoiding redundant calls to implicit destructors and improving linear
type support.
Special thanks to our community contributors: Brian Grenier (@bgreni), c-pozzi (@c-pozzi), Christoph Schlumpf (@christoph-schlumpf), cudawarped (@cudawarped), David Faden (revfad.com) (@fadend), Ethan Wu (@YichengDWu), Hardik Gupta (@hardikkgupta), j_rutzmoser (@Rutzmoser), Johnny Lin (@johnny19436), Jose (@josetorrs), josiahls (@josiahls), Luis Chamberlain (@mcgrof), Manuel Saelices (@msaelices), Marius S (@winding-lines), martinvuyk (@martinvuyk), MaxMeyberg (@MaxMeyberg), Monal (@Monal-Patel), skrript (@skrript), soraros (@soraros), and Thomas Mader (@ThomasMader).
]]>You can now pip install mojo!
Although we still love the environment reliability of Pixi,
installing Mojo with pip or uv further enhances our interoperability
with the Python ecosystem, making it easier to extend your Python code with
Mojo. For more information, see the
Mojo install guide.
We've released a new version of the Mojo extension for Visual Studio Code that now works with both the stable and nightly Mojo releases. You can install the Mojo extension from either the Visual Studio Code Marketplace or the Open VSX Registry.
The new extension replaces the old stable version, so if you have the stable version installed, you can simply update it to receive the new version. If you have the nightly version of the extension installed, you should uninstall it and install the regular (non-nightly) version. See Add the VS Code extension for more information.
New Mojo vision doc explains our motivations and design decisions for the Mojo language.
New Mojo roadmap provides a high-level roadmap for the language across multiple phases.
Mojo now has support for default trait methods, allowing traits to provide reusable behavior without requiring every conforming struct to re-implement it. Default methods are automatically inherited by conforming structs unless explicitly overridden. See Default method implementations in the Mojo Manual for more information.
Added support for many consumer GPUs, including initial support for Apple silicon GPUs. See GPU support for details.
The way copying is modeled in Mojo has been overhauled. The Copyable trait
has been updated to represent a type that can be explicitly copied (using a
copy() method), and a new ImplicitlyCopyable "marker" trait can be used to
opt-in to making a type implicitly copyable as well. This swaps the
default behavior from being implicitly copyable to being only explicitly
copyable. Several standard library traits, types, and functions now require
now require explicit Copyable instead of ImplicitlyCopyable. See
Standard library changes for more
information.
Uncaught exceptions or segmentation faults in Mojo programs can now
generate stack traces. This is currently only for CPU-based code. To generate
a fully symbolicated stack trace, set the MOJO_ENABLE_STACK_TRACE_ON_ERROR
environment variable, use mojo build with debug info enabled, e.g.
-debug-level=line-tables, and then run the resulting binary.
Major standard library improvements include:
Making the SIMD type conform to Comparable and EqualityComparable,
which means that you can use SIMD values as Dict keys, among other
things. For details, see
SIMD and related types.
A new Some[Trait] utility to make it easier to
declare an argument that conforms to a trait. For details, see
Other standard library changes.
Several enhancements to how iterators work in Mojo, including a new
Iterable trait. For more information, see
Collections and iterators changes.
Mojo now allows the use of keywords in function names (after def and fn)
and in attribute references after a .. This notably allows the use of the
match() method in regex libraries even though Mojo takes this as a hard
keyword. Uses in other locations can still use backticks:
struct MatchExample:
fn match(self): # This is ok now.
pass
fn test_match(a: MatchExample):
a.match() # This is ok now.
a.`match`() # This is still valid.
When generating error messages for complex types involving parameter calls,
the Mojo compiler now prints functions parameter values correctly, eliminating
a large class of T != T errors that happen with GPU layouts.
Methods on structs may now declare their self argument with a deinit
argument convention. This argument convention is used for methods like
__del__() and __moveinit__() to indicate that they tear down the
corresponding value without needing its destructor to be run again. Beyond
these two methods, this convention can be used to declare "named" destructors,
which are methods that consume and destroy the value without themselves
running the values destructor. For example, the standard
VariadicPack type has these
methods:
struct VariadicPack[...]:
# implicit destructor
fn __del__(deinit self): ...
# move constructor
fn __moveinit__(out self, deinit existing: Self): ...
# custom explicit destructor that destroys "self" by transferring all of
# the stored elements.
fn consume_elements[
elt_handler: fn (idx: Int, var elt: element_type) capturing
](deinit self): ...
This argument convention is a fairly narrow power-user feature that is
important to clarify the destruction model and make linear types fit into the
model better. (A linear type is just a type that has no __del__() method,
but provides a destructor that the user must call explicitly. Linear types are
a proposed feature that hasn't been fully implemented yet.)
The __del__() and __moveinit__() methods should now take their self
and existing arguments as deinit instead of either owned or var.
The __disable_del keyword and statement has been removed, use deinit
methods instead.
The Mojo compiler now warns about use of the deprecated owned keyword,
please move to var or deinit as the warning indicates.
The previously deprecated @value decorator has been removed.
Accesses to associated aliases and methods within a trait now require
qualified references (prepended with Self.), making it consistent with how
accesses to member aliases and methods in a struct require self..
The Mojo compiler now raises error on implicit materialization of a
non-ImplicitlyCopyable object, please either mark the type to be
ImplicitlyCopyable or using materialize[value: T]() to explicitly
materialize the parameter into a dynamic value.
This usually happens when you generate a compile-time value using the alias
keyword, then assign it to a runtime variable:
alias lst = [1, 2, 3, 4] # Create a compile-time list value
var dyn_list = lst # Implicitly materializes the compile-time value to a
# dynamically-allocated runtime value
The alias is a compile-time temporary value; to assign it to a runtime
variable, Mojo must allocate memory and copy the value. Since this can result
in unexpected memory allocations when materializing a memory value like a
list, Mojo only allows implicit materializations of memory values if the type
is ImplicitlyCopyable, which is a signal that the type should be inexpensive
to copy.
You can use the materialize() function to explicitly materialize a value:
var dyn_list = materialize[lst]()
The way copying is modeled in Mojo has been overhauled.
Previously, Mojo had two traits for modeling copyability:
Copyable denoted a type that could be copied implicitlyExplicitlyCopyable denoted a type that could only be copied with an
explicit call to a .copy() method.The vast majority of types defaulted to implementing Copyable (and therefore
were implicitly copyable), and ExplicitlyCopyable was partially phased in
but had significant usage limitations.
Now, the new Copyable trait instead represents a type that can be
explicitly copied (using .copy()), and a new ImplicitlyCopyable "marker"
trait can be used to opt-in to making a type implicitly copyable as well.
This swaps the default behavior from being implicitly copyable to being only
explicitly copyable.
The new ImplicitlyCopyable trait inherits from Copyable, and requires
no additional methods. ImplicitlyCopyable is known specially to the
compiler. (ImplicitlyCopyable types may also be copied explicitly using
.copy().)
This makes it possible for non-implicitly-copyable types to be used with all standard library functionality, resolving a long-standing issue with Mojo effectively forcing implicit copyability upon all types. This will enable Mojo programs to be more efficient and readable, with fewer performance and correctness issues caused by accidental implicit copies.
With this change, types that conform to Copyable are no longer implicitly
copyable:
@fieldwise_init
struct Person(Copyable):
var name: String
fn main():
var p = Person("Connor")
var p2 = p # ERROR: not implicitly copyable
var p3 = p.copy() # OK: may be copied explicitly
To enable a type to be implicitly copyable, declare a conformance to the
ImplicitlyCopyable marker trait:
@fieldwise_init
struct Point(ImplicitlyCopyable):
var x: Float32
var y: Float32
fn main():
var p = Point(5, 10)
var p2 = p # OK: may be implicitly copied
var p3 = p.copy() # OK: may be explicitly copied
An additional nuance is that ImplicitlyCopyable may only be synthesized for
types whose fields are all themselves ImplicitlyCopyable (and not merely
Copyable). If you need to make a type with any non-ImplicitlyCopyable
fields support implicit copying, you can declare the conformance to
ImplicitlyCopyable, but write the __copyinit__() definition manually:
struct Container(ImplicitlyCopyable):
var x: SomeCopyableType
var y: SomeImplicitlyCopyableType
fn __copyinit__(out self, existing: Self):
self.x = existing.x.copy() # Copy field explicitly
self.y = existing.y
For more information on copyability, see the section on copy constructors in the Mojo manual.
The following standard library types and functions now require only explicit
Copyable for their element and argument types, enabling their use with
types that are not implicitly copyable:
List,
Span,
InlineArray
Optional,
Variant,
Tuple,
Dict,
Set,
Counter,
LinkedList,
Deque, and
reversed().
Additionally, the following traits now require explicit Copyable instead
of ImplicitlyCopyable:
KeyElement, IntervalElement, ConvertibleFromPython
The following Mojo standard library types are no longer implicitly copyable:
List,
Dict,
DictEntry,
OwnedKwargsDict,
Set,
LinkedList,
Node
Counter,
CountTuple,
BitSet, UnsafeMaybeUninitialized,
DLHandle, BenchConfig,
BenchmarkInfo,
Report,
PythonTypeBuilder.
To create a copy of one of these types, call the .copy() method explicitly:
var l = List[Int](1, 2, 3)
# ERROR: Implicit copying of `List` is no longer supported:
# var l2 = l
# Instead, perform an explicit copy:
var l2 = l.copy()
Alternatively, to transfer ownership,
use the ^ transfer sigil:
var l = List[Int](1, 2, 3)
var l2 = l^
# `l` is no longer accessible.
Because List and Dict are so widely used, this release stages this in by
making implicit copies of these types a warning instead of an error. This
will become a hard error in the next release of Mojo.
User types that define a custom .copy() method must be updated to move
that logic to __copyinit__(). The .copy() method is now provided by a
default trait implementation on Copyable that should not be overridden:
trait Copyable:
fn __copyinit__(out self, existing: Self, /):
...
fn copy(self) -> Self:
return Self.__copyinit__(self)
The comparison operators (e.g. __eq__() and __le__()) of the SIMD type
now return a single Bool instead of a boolean SIMD mask. Moreover, SIMD
now has explicit element-wise comparisons that return boolean masks (for
example, eq() and le()).
SIMD to conform to the EqualityComparable trait, enabling
the use of SIMD vectors in sets, as keys to dictionaries, generic search
algorithms, etc. Moreover, Scalar now conforms to the Comparable trait,
i.e. SIMD conforms to Comparable when the size is 1.SIMD.__bool__() no longer needs to be restricted to
scalars, and instead performs an any reduction on the elements of vectors.Non-scalar SIMD constructors no longer allow implicit splatting of Bool
values. This could lead to subtle bugs that cannot be caught at compile time,
for example:
fn foo[w: Int](v: SIMD[_, w]) -> SIMD[DType.bool, w]:
return v == 42 # this silently reduced to a single bool, and then splat
Similarly to InlineArray, an explicit constructor with the fill
keyword-only argument can be used to express the same logic more safely:
fn foo[w: Int](v: SIMD[_, w]) -> SIMD[DType.bool, w]:
return SIMD[DType.bool, w](fill=(v == 42)) # highlights the splat logic
fn bar(Scalar[_]) -> Scalar[DType.bool]:
# still works, since implicit splatting to a scalar is never ambiguous
return v == 42
Several types that wrap MLIR types have been changed to further encapsulate their behavior, hiding this low-level behavior from non-advanced users.
Types that can be constructed from raw MLIR values now require the use
of an mlir_value keyword-only argument initializer.
Affected types include SIMD and UInt.
Types with raw MLIR type fields have had their value fields renamed to
_mlir_value.
Affected types include: Bool and DType.
The SIMD.from_bits() factory method is now a constructor, use
SIMD(from_bits=...) instead.
DType.index is deprecated in favor of the new DType.int. Moreover, a new
DType.uint is added, modeling unsigned integers with widths that match the
machine word length.
The index() free function now returns an Int, instead of a raw MLIR
__mlir_type.index value.
Added the parts() method to the
Path type, for example instead of writing:
var path = Path("path/to/file")
var parts = path.path.split(DIR_SEPARATOR)
you can now write:
var path = Path("path/to/file")
var parts = path.parts()
Added the name() method to the
Path type, which returns the name of the file or directory.
Added os.path.realpath() to resolve symbolic links to an absolute path and
remove relative path components (., .., etc.). Behaves the same as the
Python equivalent function.
Added an iter module which includes the new Iterable
trait (and the existing Iterator trait). The module also provides the
enumerate(),
iter(), map(),
next(), and zip()
functions. The new generic zip() function replaces the IntTuple-specific
zip() function provided in previous releases.
Iterable's origin parameter is now named iterable_origin
and its mut param is now named iterator_mut to avoid naming collisions.Iterator now has a defaulted bounds() trait
method. This returns the lower and upper bounds of the remaining length of the
iterator. This can be used for preallocation when building or extending
collections from iterators.
Added take_items()
draining iterator to Dict.
Span is now Representable if its
elements implement the Representable trait.
Add repr() support for List,
Deque,
Dict,
LinkedList,
Optional, and
Set.
InlineArray now
automatically detects whether its element types are trivially destructible to
not invoke the destructors in its __del__() function. This improves
performance for trivially destructible types (such as Int and friends).
Similar to above, List now automatically does optimizations based on
whether the element types are trivial (copyable, destructible, etc). There
is no longer a hint_trivial_type parameter as this is done automatically
now.
String.splitlines() now returns a List[StringSlice] instead of a
List[String]. This avoids unnecessary intermediate allocations.
StringSlice.from_utf8() factory method is now a constructor, use
StringSlice(from_utf8=...) instead.
Span now implements a generic .count() method which can be passed a
function that returns a boolean SIMD vector. The function counts how many
times it returns True evaluating it in a vectorized manner. This works for
any Span[Scalar[D]] e.g. Span[Byte].
Optional and
OptionalReg can now be
composed with Bool in expressions, both at comptime and runtime:
alias value = Optional[Int](42)
@parameter
if CompilationTarget.is_macos() and value:
print("is macos and value is:", value.value())
sort(),
LinkedList.pop(),
LinkedList.maybe_pop()
and Dict.popitem() no longer
copy elements, improving performance.
The IndexList and DimList types may no longer be implicitly constructed
from tuple values. Most existing call sites already used explicit initializer
calls (IndexList(...)), so implicit conversions have been removed to ensure
uniformity and consistency.
Removed the alignment parameter and static_alignment_cast() method from
UnsafePointer. This
alignment parameter that was only used by the alloc() static method.
Added an alignment keyword argument to UnsafePointer.alloc(). Use this
in place of the alignment parameter on the struct.
Removed the alignment parameter from Span, similar to UnsafePointer
above.
The UnsafePointer.init_pointee_explicit_copy() method has been removed.
Please use
UnsafePointer.init_pointee_copy()
instead.
UnsafePointer.move_pointee_into() has been deprecated. Please use
UnsafePointer.init_pointee_move_from().
src.move_pointee_into(dst) used a reversed argument order from intuitive
LHS = RHS semantics for assignment, effectively RHS -> LHS. The new
function fixes this readability issue (dst.init_pointee_move_from(src)), and
additionally follows the init_pointee_*() naming convention of the other
existing methods for initializer a pointer memory location.
Added os.atomic.fence() for creating atomic
memory fences.
from os.atomic import Atomic, Consistency, fence
fn decrease_ref_count(ref_count: Atomic[DType.uint64]):
if atomic.fetch_sub[ordering = Consistency.MONOTONIC](1) == 1:
fence[Consistency.ACQUIRE]()
# ...
Add a memory ordering parameter to
Atomic.load().
Added sys.info.platform_map() for specifying types that can have different
values depending on the platform:
from sys.info import platform_map
alias EDEADLK = platform_map["EDEADLK", linux = 35, macos = 11]()
Renamed a number of functions following functions in sys.info from
flatcase to snake_case names:
| Old name | New name |
|---|---|
alignof() | align_of() |
bitwidthof() | bit_width_of() |
simdbitwidth() | simd_bit_width() |
simdbytewidth() | simd_byte_width() |
simdwidthof() | simd_width_of() |
sizeof() | size_of() |
The old names are deprecated, and will be removed in the next release.
Added initial support for programming Apple Silicon GPUs in Mojo. However, MAX graphs are not yet enabled on Apple Silicon GPUs, and many hardware features remain to be enabled.
Added support for AMD RX 6900 XT consumer-grade GPU.
Added support for AMD RDNA3.5 consumer-grade GPUs in the gfx1150, gfx1151,
and gfx1152 architectures. Representative configurations have been added for
AMD Radeon 860M, 880M, and 8060S GPUs.
Added support for NVIDIA GTX 1080 Ti consumer-grade GPUs.
Added support for NVIDIA Tesla P100 datacenter GPUs.
Updated layout_tensor() copy related functions to support 2D and 3D
threadblock dimensions.
A new Some utility is introduced to reduce the syntactic load of declaring
function arguments of a type that implements a given trait or trait
composition. For example, instead of writing
fn foo[T: Intable, //](x: T) -> Int:
return x.__int__()
one can now write:
fn foo(x: Some[Intable]) -> Int:
return x.__int__()
The
compile.reflection.get_type_name()
utility now has limited capability to print parametric types, e.g.
SIMD[DType.float32, 4] instead of just SIMD. If the parameter is not
printable, an <unprintable> placeholder is printed instead. A new
qualified_builtins flag also allows users to control the verbosity for the
most common (but not all) builtin types.
A fast matmul for SM100 is available in Mojo. Please check it out in
matmul_sm100.mojo.
Moved the
comm
module from the standard library (gpu.comm) to the MAX AI kernels library.
Any imports that used gpu.comm should be updated to comm, instead.
mojo test now ignores folders with a leading . in the name. This will
exclude hidden folders on Unix systems.
mojo doc --validate-doc-strings now emits a warning when an fn function is
declared to raise an error (raises) and it has no
Raises docstring.
However, because Mojo automatically treats all def functions as
raising functions,
we do not enforce Raises docs for def functions (to avoid noisy false
positives).
Nightly mojo Python wheels are now available. To install everything needed
for Mojo development in a Python virtual environment, you can use:
pip install --pre mojo \
--index-url https://dl.modular.com/public/nightly/python/simple/
For more information, see the Mojo install guide.
In preparation for a future Mojo 1.0, the mojo and mojo-compiler packages
have a 0. prefixed to the version.
Dict.__getitem__()
always returns immutable references.__getitem__() if [] operator is used and __setitem__() is
present.Log1p() not
working on GPUs.CLAUDE.md
docs.LayoutTensor[layout] with no layout in scope.Special thanks to our community contributors: @AceMouse, @Alex-Mann, @christoph-schlumpf, @cudawarped, @cyrillzadra, @dl-alexandre, @farnoy, @gabrieldemarmiesse, @gryznar, @josiahls, @kyoto7250 @martinvuyk, @mmicu, @msaelices, @mzaks, @rd4com, @Rtosshy, @SasankYadati, @simonyjung, @soraros, and @ThomasMader.
]]>Mojo is now available independently as the mojo Conda package. In includes
the Mojo compiler, standard library, and the layout package (which is
heavily used in GPU programming). It also includes the Mojo developer tools:
LSP, debugger, formatter, and so on.
To use Python to Mojo interoperability in v25.5, you must install the
modular package. This will move to the mojo package in a future release.
For more details, see the install guide.
Parametric aliases are now supported: Aliases can be specified with an optional parameter list (just like functions). Parametric aliases are considered first class parameter values, too. For more details, see Parametric aliases in the Mojo Manual.
Mojo API documentation now generates cross-references for parameter, argument, and return value types.
@parameter for now works on a broader range of collection types, enabling
things like @parameter for i in [1, 2, 3]: ....
StringLiteral now automatically materializes to a String when used at
runtime:
alias param = "foo" # type = StringLiteral
var runtime_value = "bar" # type = String
var runtime_value2 = param # type = String
This enables all the behavior users expect without having to convert or annotate types, for example:
var string = "hello"
string += " world"
var if_result = "foo" if True else "bar"
Initializing a String from a StringLiteral initially points to static
constant memory, and does not perform any allocation until the first mutation.
The compiler now detects attempts to materialize references to compile-time interpreter stack memory into runtime code. This includes related types that reference memory, like slices, spans, and pointers.
The compiler cannot currently track the lifetime of internal stack objects when materialized to runtime, which could cause memory leaks. Consider this example:
fn test_comptime_materialize():
# This is ok! Forms a comptime pointer to a comptime "stack" value of
# String type.
alias comptime_ptr = String("foo" + "bar").unsafe_ptr()
# This is ok too, dereferences the pointer at comptime, loading the byte.
alias byte = comptime_ptr[]
# This materializes a Byte from comptime to runtime.
var rt_byte = byte
# Error: cannot materialize to runtime value, the type contains an origin
# referring to a compile-time value
var bad_usage = comptime_ptr
Previously the compiler would materialize the memory representation of the
String value but not know it needs to be destroyed. It now detects the
problem. If you run into this, rework the code to materialize the full object
(e.g. the String) to runtime explicitly:
alias comptime_string = String("foo" + "bar")
var runtime_string = comptime_string
The @value decorator has been formally deprecated with a warning, it will
be removed in the next release of Mojo. Please move to the
@fieldwise_init
and synthesized Copyable and Movable trait conformance.
Implicit trait conformance is removed. All conformances must be explicitly declared.
The owned argument convention is being renamed to var. This reflects that
var is used consistently for a "named, scoped, owned value" already
which is exactly what the owned convention does. In this release, both
var and owned are allowed in an argument list, but owned will be removed
in a subsequent release, so please move your code over.
Function overloading is now fully supported as long as, among two function signatures with the same list of argument types, one position is a keyword-only argument in at least one signature, and that position differs in argument name. Previously an edge case prevented this support when the return types are different. For example, these two functions can now co-exist:
fn get(self, idx: Int) -> Int
fn get(self, *, idx2: Int) -> Float32
Indexing into a String now
returns a
StringSlice,
avoiding an allocation. String.split() now returns a List[StringSlice].
Added support for a wider range of consumer-grade AMD hardware, including:
Compile-time checks for AMD RDNA3+ GPUs are now provided by the following
functions (which can be imported from sys.info):
_is_amd_rdna3()_is_amd_rdna4()_is_amd_rdna()Added WMMA matrix-multiplication instructions for RDNA3+ GPUs to help support running AI models on those GPUs.
Added support for NVIDIA GeForce RTX 3090.
memory.UnsafePointer is
now implicitly included in all mojo files. Moreover,
OpaquePointer (the
equivalent of a void* in C) is moved into the memory module, and is also
implicitly included.
Python interop changes:
Mojo methods can now take py_self: UnsafePointer[Self] instead of the raw
py_self: PythonObject, eliminating the downcasting boilerplate required
in the common case.
Mojo functions can now natively accept
keyword arguments from Python using OwnedKwargsDict[PythonObject] as the
last parameter. This enables direct calling from Python with keyword
arguments without requiring wrapper functions.
from collections import OwnedKwargsDict
# Callable from Python as `foo(10, y=20)`
fn foo(x: PythonObject, kwargs: OwnedKwargsDict[PythonObject]):
y = kwargs["y"]
The PythonTypeBuilder
utility now allows:
Defaultable to be exposed and created from Python.The PythonConvertible trait has been renamed to
ConvertibleToPython.
This is now consistent with the
ConvertibleFromPython
trait, modeling Mojo types that can be converted either to or from a
PythonObject.
For more information, see Calling Mojo from Python in the Mojo Manual.
Added Iterator trait for modeling
types that produce a sequence of values.
A type can implement Iterator by providing __next__() and __has_next__()
methods. This naming and behavior is based on
the Python
Iterator
type annotation, diverging slightly due to constraints present in Mojo today.
Any type that implements Iterator can be used within for and
@parameter for looping syntax.
Iterator does not currently have a variant for supporting iteration over
borrowed ref values.
The Dict type now has an H
parameter which allows users to provider a custom Hasher type.
default_hasher (AHasher) and default_comp_time_hasher (Fnv1a)
are now providedH parameter of Dict defaults to default_hasherThe Hashable trait has been updated to
use a new data flow strategy.
fn __hash__[H: Hasher](self, mut hasher: H):
(see the Hashable API documentation for further details).InlineArray can now be constructed with a size of 0. This makes it easier to
use InlineArray in situations where the number of elements is generic and
could also be 0.
List.append(Span) has been renamed to List.extend(Span). It is important
for readability and consistency that append() always grows the length of
the list by exactly 1. extend() in both Python and Rust is the variant of
this operation that takes an arbitrary-length number of additional elements
(possibly 0) to add to the list.
A new io module is available in the library. Some core
input/output APIs previously in the builtin module have been moved to io.
Currently all of the APIs in the io module are imported automatically. The
following APIs were moved to io:
open(), FileHandle and FileDescriptor.Writer and Writable traits.input() and print() functions.StringLiteral.strip() family of functions now return a StaticString.
Added support for GCC-style debug flags -g0, -g1, and -g2 to match
common compiler conventions:
-g0: No debug information (alias for --debug-level=none).-g1: Line table debug information (alias for --debug-level=line-tables).-g2: Full debug information (alias for --debug-level=full).Added progress reporting support to the Mojo language server. This will emit progress notifications in your editor when the server is currently parsing a document.
Various functions from the sys.info package have been moved to the
sys.info.CompilationTarget
struct:
is_x86()has_sse4()has_avx()has_avx2()has_avx512f()has_fma()has_vnni()has_neon()has_neon_int8_dotprod()has_neon_int8_matmul()UnsafePointer.address_of() has been removed. Use UnsafePointer(to=...)
constructor instead. Similarly, Pointer.address_of() has been removed.
DType.tensor_float32 has been removed due to lack of support for it in the
library and the compiler.
#4121 - better error message
for .value() on empty Optional.
#4566 - Hang when assigning
loop variable inside @parameter for.
#4820 - math.exp2 picks
the wrong implementation for float64.
#4836 - Else path in
@parameter for broken.
#4499 - Traits with
ref self cause issues when used as parameter.
#4911 - InlineArray
now calls the move constructor for its elements when moved.
#3927 - InlineArray
now can be constructed with a size of 0.
#4954 - InlineArray
now does not call the copy constructor when being moved.
#5066 - Correctly fill
64-bit values on AMD in enqueue_fill.
#4982 - Add toggle_all
to BitSet.
#5086 - Add set_all
to BitSet.
#5057 - Span Performance Regression.
#5051 - Incorrect
.modular Directory Location on Linux.
#5021 - LSP Crashes in VSCode when a local package exists.
#5016 - Conditional Conformance Trait Alias Bug.
Special thanks to our community contributors:
@zsiegel92, @yeison, @soraros, @samufi, @mzaks, @mmicu, @martinvuyk, @hardikkgupta, @gustawdaniel, @cyrillzadra, @cnhz95, @christoph-schlumpf, @bgreni, @benz0li, @LeeLee26, @Caslyn, @Amila-Rukshan, @Amet13, and @AceMouse.
]]>Mojo now supports AMD GPUs, expanding hardware compatibility beyond NVIDIA to include AMD's GPU ecosystem. This enables Mojo applications to leverage AMD's RDNA and CDNA architectures for high-performance computing workloads, providing developers with greater flexibility in choosing hardware platforms for AI and compute-intensive applications.
Primitives for working with NVIDIA Blackwell GPUs have been added, providing low-level access to the latest GPU architecture features. These primitives enable developers to take advantage of Blackwell's enhanced compute capabilities, improved memory bandwidth, and advanced AI acceleration features, including support for newer tensor operations and optimized memory management patterns.
The Python-Mojo bindings are available as a preview release! This is the ability to call into Mojo functions from existing Python codebases. The use case is to speed up hot spots/slow Python code by rewriting certain portions of your code in Mojo to achieve performance.
Mojo collection types received many enhancements.
List,
Set, and
Dict literals have been
reimplemented to provide Python-equivalent features and syntax, including
simple literals like [1, 2, 3] and {k1: v1, k2: v2}.
List comprehensions like
[a*b for a in range(10) if isprime(a) for b in range(20)]
as well as dictionary and set comprehensions are now supported.
Iterating over a collection with a for loop no longer requires using the
[] deference operator.
See Language enhancements and Standard library changes for more details.
The entire MAX Kernel library is now fully open sourced! For more information, see the MAX AI kernels library reference and the MAX AI kernels source.
Mojo is now available on Godbolt.org, which is also known as the "Compiler Explorer".
var declarations in functions now support more flexible "patterns", allowing
multiple values to be declared at once, for example var a, b = 4, 5 and
var a, b : Int, Float64.
Mojo now supports the use of Python-style type patterns when declaring
variables on first assignment without the var keyword. For example, x = 4; y: UInt8 = 5 declares both x and y, where x is inferred to the default
type of Int whereas y gets the explicit type UInt8. Declaring variables
without var gives you a function-scoped name, whereas var makes things
scoped to the statement they are in (lexical scoping), such as the body of an
if statement.
Mojo now supports ref patterns that bind a stored LValue into a named
declaration, extending the argument convention into local function scope.
This can be useful when you want to do something with a reference, but don't
want the conceptual overhead of a
Pointer. These are equivalent:
fn use_pointer(your_list: List[Int]):
var p = Pointer(to=your_list[i]) # Form a safe pointer
...
use(p[]) # dereference it
fn use_ref(your_list: List[Int]):
ref r = your_list[i] # Bind element reference to 'r'
...
use(r) # use it
References are bound in their initializer and cannot be mutated afterward: uses and mutations of the reference are interpreted as uses and mutations of the value referenced by the value.
The Mojo compiler will now synthesize __moveinit__(), __copyinit__(), and
copy() methods for structs that conform to
Movable,
Copyable, and ExplicitlyCopyable
(respectively) but that do not implement the methods explicitly.
A new @fieldwise_init decorator
can be attached to structs to synthesize a field-wise initializer—an
__init__() method that takes the same arguments as the fields in the struct.
This gives access to this helpful capability without having to opt into the
rest of the methods that @value synthesizes. This decorator allows an
optional @fieldwise_init("implicit") form for single-element structs, which
marks the initializer as @implicit.
try and raise now work at compile time.
"Initializer lists" are now supported for creating struct instances with an inferred type based on context, for example:
fn foo(x: SomeComplicatedType): ...
# Example with normal initializer.
foo(SomeComplicatedType(1, kwarg=42))
# Example with initializer list.
foo({1, kwarg=42})
List literals have been redesigned to work better. They produce homogenous
sequences by invoking the T(<elements>, __list_literal__: ()) constructor of
a type T that is inferred by context, or otherwise defaulting to the
standard library List type. The
ListLiteral type has been removed from the standard library.
Dictionary and set literals now work and default to creating instances of the
Dict and
Set types in the collections library.
Implicit trait conformance is deprecated. Each instance of implicit conformance results in a warning, but compilation still goes through. Soon it will be upgraded into an error. Any code currently relying on implicit conformance should either declare conformances explicitly or, if appropriate, replace empty, non-load-bearing traits with trait compositions.
Mojo doesn't allow the use of out or mut as an argument name any longer.
Previously you could use fn x(out: Int), but this causes ambiguity with
function types. Please use names like output instead.
def arguments are no longer implicitly mutable. If you would like to have a
locally mutable argument, declare it owned explicitly.
Global (file-scope) variables are deprecated. Global variables in Mojo are only partially implemented and are known to cause cryptic errors. Now the Mojo compiler issues a warning on global variable usage.
GPU programming enhancements and changes:
Mojo now supports AMD GPUs, expanding hardware compatibility beyond NVIDIA to include AMD's GPU ecosystem. This enables Mojo applications to leverage AMD's RDNA and CDNA architectures for high-performance computing workloads, providing developers with greater flexibility in choosing hardware platforms for AI and compute-intensive applications.
Primitives for working with NVIDIA Blackwell GPUs have been added, providing
low-level access to the latest GPU architecture features. These primitives
enable developers to take advantage of Blackwell's enhanced compute
capabilities, improved memory bandwidth, and advanced AI acceleration
features, including support for newer tensor operations and optimized memory
management patterns. See the
gpu.tcgen05 module API reference
documentation for more information.
Added support for a wider range of consumer-grade hardware, including:
Fixed the sum() and prefix_sum() implementations in the
gpu.block and
gpu.warp modules. Previously, the
implementations have been incorrect and would either return wrong results or
hang the kernel (due to the deadlock). PR
4508 and PR
4553 by Kirill
Bobyrev mitigate the found issues and add
tests to ensure correctness going forward.
Collection type enhancements and changes:
The Dict type is now part of the
prelude, so there is no need to import it anymore.
The List,
Span,
Dict,
Set,
VariadicPack, and
Deque iterators now return
references to elements directly, instead of returning
Pointer. This means that you
should no longer use the [] deference operator with the loop index
variable:
var states: List[String] = ["California", "Hawaii", "Oregon"]
# Old:
for state in states:
print(state[])
# New:
for state in states:
# state is an immutable reference
print(state)
By default the reference is immutable. You can use the ref keyword
to bind the index variable as a mutable reference:
for ref state in states:
# state is a mutable reference
state += "!" # Update the existing list element
List,
InlineArray,
Deque,
LinkedList, and
SIMD types all support construction via
list literal syntax:
var list: List[Int] = [1, 2, 3]
var vec: SIMD[DType.uint8, 8] = [1, 2, 3, 4, 5, 6, 7, 8]
var deque: Deque[Float64] = [1, 2.5]
var llist: LinkedList[Int] = [1, 2, 3]
var arr: InlineArray[String, 3] = ["hi", "hello", "hey"]
Dict and
Set support construction via dict
literal and set literal syntax, respectively:
var dict1 = {String("foo"): 1, String("bar"): 2} # Dict[String, Int]
var dict2 = {1: 4, 2: 7, 3: 18} # Dict[Int, Int]
var set = {1, 2, 3} # Set[Int]
Python-style list, dictionary, and set comprehensions are now supported. For example:
# Basic list comprehension using a List[String]
var upper_strs = [str.upper() for str in strs] # List[String]
# Nested list comprehension with conditional expression
var nums = [a * b for a in range(1, 5) if a % 2 == 0 for b in [-1, 1]] # List[Int]
# Dictionary comprehension
var squares_dict = {num: num * num for num in range(10)} # Dict[Int, Int]
# Set comprehension
var unique_remainders = {num % 4 for num in range(10)} # Set[Int]
The BitSet data structure was
added to the collections package. This is a
fixed BitSet that simplifies working with a set of bits and performing bit
operations.
VariadicList,
VariadicListMem, and
VariadicPack moved to the
new variadics module.
The CollectionElement trait has been removed. You can replace any use of
it with the Copyable and
Movable traits, or the
Copyable & Movable
trait composition.
Python-Mojo interoperability enhancements and changes:
Python objects are now constructible with list, set, and dict literal syntax,
for example: var list: PythonObject = [1, "foo", 2.0] will produce a Python
list containing other Python objects and var d: PythonObject = {} will
construct an empty dictionary.
Python.unsafe_get_python_exception() and
Python.throw_python_exception_if_error_state() have been removed in favor of
Python().cpython().unsafe_get_error() and Python().cpython().get_error().
Since virtually any operation on a
PythonObject can raise,
the PythonObject struct no longer implements the
Indexer and
Intable traits. Instead, it now
conforms to IntableRaising, and
users should convert explicitly to built-in types and handle exceptions as
needed. In particular, the
PythonObject.__int__()
method now returns a Python int instead of a mojo Int, so users must
explicitly convert to a mojo Int if they need one (and must handle the
exception if the conversion fails, for example due to overflow).
PythonObject no longer
implements the following traits:
Stringable. Instead, the
PythonObject.__str__()
method now returns a Python str object and can raise. The new
Python.str() static method can
also be used to convert an arbitrary PythonObject to a Python str
object.
KeyElement. Since Python
objects may not be hashable—and even if they are, they could theoretically
raise in the
__hash__()
method—PythonObject cannot conform to
Hashable. This has no effect on
accessing Python dict objects with PythonObject keys, since
__getitem__()
and
__setitem__()
should behave correctly and raise as needed. Two overloads of the
Python.dict() factory function
have been added to allow constructing dictionaries from a list of key-value
tuples and from keyword arguments.
EqualityComparable.
The
PythonObject.__eq__()
and
PythonObject.__ne__()
methods need to return other PythonObject values to support rich
comparisons. Code that previously compared PythonObject values should be
wrapped in Bool() to perform
the fallible conversion explicitly: if Bool(obj1 == obj2): ....
Floatable. An explicit,
raising constructor is added to
SIMD to allow constructing
Float64 values from PythonObject values that implement __float__().
A new
def_function()
API was added to
PythonModuleBuilder to
allow declaring Python bindings for arbitrary functions that take and return
PythonObjects. Similarly, a new
def_method()
API is added to
PythonTypeBuilder to allow
declaring Python bindings for methods that take and return PythonObjects.
The
ConvertibleFromPython
trait is now public. This trait is implemented by Mojo types that can be
constructed by converting from a PythonObject. This is the reverse operation
of the
PythonConvertible
trait.
PythonObject(alloc=<value>)
is a new constructor that can be used to directly store Mojo values in Python
objects.
This initializer will fail if the type of the provided Mojo value has not
previously had a corresponding Python type object globally registered using
PythonModuleBuilder.add_type().
PythonObject has new
methods for downcasting to a pointer to a contained Mojo value, for use in
Python/Mojo interop.
struct Person:
var name: String
fn greet(obj: PythonObject) raises:
var person = obj.downcast_value_ptr[Person]()
print("Hello ", person[].name, "from Mojo🔥!")
PythonObject.downcast_value_ptr[T]()
checks if the object is a wrapped instance of the Mojo type T, and if so,
returns an UnsafePointer[T]. Otherwise, an exception is raised.
PythonObject.unchecked_downcast_value_ptr[T]()
unconditionally returns an UnsafePointer[T] without any runtime type
checking. This is useful when using Python/Mojo interop to optimize an inner
loop and minimizing overhead is desirable.
Also added an equivalent
UnsafePointer
initializer for downcasting from a PythonObject.
The TypedPythonObject type has been removed. Use PythonObject instead.
The Python.is_type(x, y) static method has been removed. Use the
expression x is y instead.
os.abort(messages) no longer supports a
variadic number of Writable messages.
While this API was high-level and convenient, it generated a lot of IR for
simple and common cases, such as when we have a single StringLiteral
message. We now no longer need to generate a bunch of bloated IR and instead,
callers must create the String on their side before calling
os.abort(message).
The atof() function has been
entirely rewritten as it produced incorrect results for very low and very high
exponents. It now works correctly for strings with fewer than 19 digits left
of the e. For example 1.1385616158185648648648648648616186186e-3 won't
work, and will raise an error. Anything that does not produce an error is now
guaranteed to be correct. While the current implementation is not the fastest,
it's based on the paper Number Parsing at a Gigabyte per
Second by Daniel Lemire. So with a bit of
effort to pinpoint the slow parts, we can easily have state of the art
performance in the future.
The math.isclose() function now supports
both symmetric (Python-style) and asymmetric (NumPy-style) comparison modes
via a new symmetrical parameter. The parameter defaults to the newly added
symmetric support. The function now only supports floating-point types,
removing previous pseudo-support for integer and boolean types. Support added
in PR 4608 by
@soraros.
The compile module now provides the
get_type_name() function
to get the fully qualified name of a type. For example,
compile.get_type_name[Int]() returns "std.builtin.int.Int".
Added support for emitting LLVM Intermediate Representation (.ll) using
--emit=llvm.
mojo build --emit=llvm YourModule.mojoRemoved support for the command line option --emit-llvm in favor of
--emit=llvm.
Added support for emitting assembly code (.s) using --emit=asm.
mojo build --emit=asm YourModule.mojoAdded associated alias support for documentation generated via mojo doc.
Added struct and trait conformance list sorting support to mojo format.
VariadicPack.each() and VariadicPack.each_idx() methods have been removed.
Use the @parameter for
language construct to achieve this now. The write_buffered() and
write_args() functions have also been removed, to improve compile speed and
reduce register pressure on GPU, you should now unroll the variadic pack at
each call site:
Unbuffered:
fn write[*Ts: Writable](mut self, *args: *Ts):
var string = String()
@parameter
for i in range(args.__len__()):
args[i].write_to(string)
Buffered:
from utils.write import _WriteBufferStack
fn write[*Ts: Writable](mut self, *args: *Ts):
var string = String()
var buffer = _WriteBufferStack(string)
@parameter
for i in range(args.__len__()):
args[i].write_to(buffer)
buffer.flush()
math.sqrt
products incorrect results for large inputs.UIntN Comparison
Yields Incorrect Result When Function Parameter Is Involved
(UInt8–UInt64).gt and le comparisons.x or y expressions with PythonObject.Dict.setdefault
should not be marked with raises.Special thanks to our community contributors:
@astrobdr, @bgreni, @gabrieldemarmiesse, @godardt, @hardikkgupta, @Hundo1018, @kirillbobyrev, @martinvuyk, @msaelices, @mzaks, @OwenJRJones, @shogo314, @sibarras, @simveit, @soraros, @sstadick
]]>Parts of the Mojo standard library continue to be progressively open sourced! Packages that are open sourced now include:
For more information, see the Standard library reference and the Standard library source.
Parts of the MAX AI kernels library continue to be progressively open sourced! Packages that are open sourced now include:
For more information, see the MAX AI kernels library reference and the MAX AI kernels source.
Trait compositions are now supported via the & syntax. A trait composition
combines two traits into one logical trait whose constraint set is the union
of the constraint sets of the two original traits. For more information, see
Trait compositions in the Mojo
Manual.
String types in Mojo got several significant improvements. See Standard library changes for details.
Mojo can now use
user-declared __merge_with__() dunder methods
to merge values when using different types in ternary operations. This has
been adopted to allow pointers to work naturally with the ternary operator,
for example var x = one_pointer if cond else other_pointer.
Auto-parameterization now extends to struct metatypes. For example, this
declaration fn foo[M: type_of(StringLiteral[_])] will auto-parameterize
on the unbound parameter of StringLiteral.
The Mojo compiler now warns about stores to values that are never used, e.g.:
x = foo(); x = bar() will warn about the first assignment to x because
it is overwritten. You can generally address this by deleting dead code, or
by assigning to _ instead: _ = foo(); x = bar(). You may also encounter
this in variable declarations, e.g. var x = 0; ...; x = foo(). In this
case, change the variable to being declared as uninitialized, e.g.
var x: Int. You may also silence this warning entirely for a variable by
renaming it to start with an underscore, e.g. _x.
The Mojo compiler now warns about obsolete use of mut self in initializers,
please switch over to fn __init__(out self) instead.
def functions now require type annotations on arguments, and treat a missing
return type as returning None. Previously these defaulted to the object
type which led to a variety of problems. Support for object has been
removed until we have time to investigate a proper replacement.
String types in Mojo got several significant improvements:
The String type no longer
copies data from
StringLiteral and
StaticString since
they are known-static-constant values. This allows us to make construction
from these values be implicit, which improves ergonomics and performance
together. It also implements the "small string optimization", which avoids
heap allocation for common short strings. On a 64-bit system, String can
hold up to 23 bytes inline. Its copy constructor is now O(1), performing
string data copy lazily on mutation.
The types
StringSlice and
StaticString
are now part of the prelude, there is no need to import them anymore. These
are useful for code that just needs a "view" of string data, not to own and
mutate it.
The StringLiteral type
has been moved to a more reliable "dependent type" design where the value of
the string is carried in a parameter instead of a stored member. This defines
away a category of compiler crashes when working with StringLiteral that
involved attempting to manipulate a StringLiteral at run time. As a
consequence of this change, many APIs should switch to using
StaticString instead
of StringLiteral. For more information on this "dependent type" design for
literals, see the proposal,
Fixing Simple Literals in Mojo.
String supports a new String(unsafe_uninit_length=x) constructor and
str.resize(unsafe_uninit_length=x) for clients that want to allocate space
that they intend to fill in with custom unsafe initialization patterns. The
String(ptr=x, length=y) constructor has been removed.
String supports working with legacy C APIs that assume null termination,
but the details have changed: String is now no longer implicitly
null-terminated, which means that it is incorrect to assume that
str.unsafe_ptr() will return a null-terminated string. For that, use the
str.unsafe_cstr_ptr() method. It now requires the string to be mutable in
order to make null-termination lazy on demand. This improves performance for
strings that are not passed to legacy APIs.
The List type has been improved
similarly to String to reduce inconsistency and enable power-user features,
including removing adding List(unsafe_uninit_length=x) and
list.resize(unsafe_uninit_size=n) methods avoid initialized memory that the
caller plans to overwrite.
Set now conforms to the
Copyable trait so you can store sets
in other types of collections (for example, as values in a Dict).
The following traits have been removed in favor of trait composition:
EqualityComparableCollectionElement, RepresentableCollectionElement,
TestableCollectionElement, Testable, StringableIdentifiable,
StringableCollectionElement, IntervalPayload, WritableCollectionElement,
ComparableCollectionElement, BoolableCollectionElement,
EqualityComparableWritableCollectionElement,
EqualityComparableWritableCollectionElementNew, CollectionElementNew,
WritableCollectionElementNew.
For example, you can replace EqualityComparableCollectionElement with
EqualityComparable & CollectionElement. StringableCollectionElement was
already deprecated and scheduled to be removed; it can be replaced with
Writable & CollectionElement.
The PythonObject type is
being reworked in preparation for some improvements to Mojo-Python
interoperability:
Since virtually any operation on a PythonObject can raise, the
PythonObject struct no longer implements the following traits:
ImplicitlyBoolable, ImplicitlyIntable.
PythonObject is no longer implicitly constructible from tuple or list
literals. For example, var x : PythonObject = [1, 2, "foo"] is no longer
accepted. Instead, please use the new Python.list() and Python.tuple()
factory methods. For example:
var x = Python.list(1, 2, "foo")
(The list() and tuple() factory methods were originally added on
PythonObject, but have been moved to the Python struct.)
We hope to re-enable literal syntax in the future as the standard library matures.
PythonObject.from_borrowed_ptr() has been removed in favor of a
constructor with a keyword-only from_borrowed_ptr argument.
The deprecated PythonObject.to_float64() method has been removed. Use the
Float64() constructor, instead.
Span now has a swap_elements() method
which takes two indices and swaps them within the span.
Pointer now has a get_immutable()
method to return a new Pointer with the same underlying data but with an
ImmutableOrigin.
You can now forward a
VariadicPack where all
values are Writable to a writer using WritableVariadicPack:
from utils.write import WritableVariadicPack
fn print_message[*Ts: Writable](*messages: *Ts):
print("message:", WritableVariadicPack(messages), "[end]")
x = 42
print_message("'x = ", x, "'")
message: 'x = 42' [end]
In this example the variadic pack is buffered to the stack in the print call
along with the extra arguments, before doing a single syscall to write to
stdout.
debug_assert() in AMD GPU
kernels now behaves the same as on NVIDIA, printing the thread information and
variadic args passed after the condition:
from gpu.host import DeviceContext
fn kernel():
var x = 1
debug_assert(x == 2, "x should be 2 but is: ", x)
def main():
with DeviceContext() as ctx:
ctx.enqueue_function[kernel](grid_dim=2, block_dim=2)
Running mojo run -D ASSERT=all [filename] will output:
At /tmp/test.mojo:5:17: block: [0,0,0] thread: [0,0,0] Assert Error: x should be 2 but is: 1
At /tmp/test.mojo:5:17: block: [0,0,0] thread: [1,0,0] Assert Error: x should be 2 but is: 1
At /tmp/test.mojo:5:17: block: [1,0,0] thread: [0,0,0] Assert Error: x should be 2 but is: 1
At /tmp/test.mojo:5:17: block: [1,0,0] thread: [1,0,0] Assert Error: x should be 2 but is: 1
The
constrained[cond, string]()
function now accepts multiple strings that are printed concatenated on
failure, so you can use:
constrained[cond, "hello: ", String(n), ": world"]()
This is more compile-time efficient and somewhat more ergonomic than using string concatenation.
pathlib.Path.write_text() now
accepts a Writable argument instead of a Stringable argument. This makes
the function more efficient by removing a String allocation.
Added
pathlib.Path.write_bytes()
which enables writing raw bytes to a file.
Added
os.path.split_extension() to
split a path into its root and extension.
Added os.path.is_absolute() to
check if a given path is absolute or not.
One can now specify the consistency model used in atomic operations with the
default being sequential consistency. The consistency models are defined in
the Consistency struct.
Added
Variant.is_type_supported()
method. (PR #4057) Example:
def takes_variant(mut arg: Variant):
if arg.is_type_supported[Float64]():
arg = Float64(1.5)
def main():
var x = Variant[Int, Float64](1)
takes_variant(x)
if x.isa[Float64]():
print(x[Float64]) # 1.5
The type parameter of SIMD has been renamed to dtype.
The is_power_of_two(x) function in the bit package is now a method on
Int, UInt and SIMD.
The Pointer.address_of(...) and UnsafePointer.address_of(...) functions
have been deprecated. Please use the
Pointer(to=...) and
UnsafePointer(to=...)
constructors instead. Conceptually, this is saying "please initialize a
Pointer (a reference, if you will) to some other address in memory. In the
future, these address_of() functions will be removed.
Fixed SIMD boolean display in debugger: SIMD boolean values now display correctly with proper bit extraction.
Improved language server performance: The language server now avoids parsing more than it needs to, improving performance across the board.
The Mojo compiler is now able to interpret all arithmetic operations from
the index dialect that are used in methods of Int and UInt types.
That allows users to finally compute constants at compile time:
alias a: Int = 1000000000
alias b: Int = (5 * a) // 2
Previously, the compiler would throw the error "cannot fold operation".
Added a new --emit-llvm option to the mojo build command, which allows
users to emit LLVM IR. When --emit-llvm is specified, the build process
will: compile mojo code to LLVM IR, save the IR to a .ll file (using the same
name as the input file), and print the IR to stdout for immediate inspection.
__mlir_op is now limited to inherent
attributes (those defined by the op definition). Most users will not need to
attach other kinds of attributes, and this helps guard against typos and mojo
code getting outdated when the dialect changes.The SIMD.roundeven() method has been removed from the standard library.
This functionality is now handled by the
round() function.
Error messages about the obsolete borrowed and inout keywords, as well as
the obsolete -> Int as name syntax have been removed.
The object type has been removed.
utils.numerics.ulp has been removed. Use the
ulp() function from the math package
instead.
Several free functions that were deprecated in the 25.2 release have now been removed. This includes:
str free function. Use the String constructor instead.int free function. Use the Int constructor instead.bool free function. Use the Bool constructor instead.float free function. Use the Float64 constructor instead.Removed deprecated
DeviceContext methods
copy_sync() and memset_sync().
The unroll() utility has been removed. Use the
@parameter for construct
instead.
from utils.loop import unroll
# Before
@always_inline
@parameter
fn foo[i: Int]():
body_logic[i]()
unroll[foo, iteration_range]()
# After
@parameter
for i in range(iteration_range):
body_logic[i]()
The InlinedString type has been removed. Use String instead which now
supports the Small String Optimization (SSO).
The AsBytes trait has been removed.
#3510 - PythonObject
doesn't handle large UInt64 correctly.
#3847 - Count leading zeros
can't be used on SIMD at compile time.
#4198 - Apple M4
is not properly detected with sys.is_apple_silicon().
#3662 - Code using
llvm.assume cannot run at compile time.
#4273 -
count_leading_zeros doesn't work for vectors with size > 1 at compile time.
#4320 - Intermittent miscompilation with bytecode imported traits.
#4281 - MAX does not support RTX 5000-series GPUs.
#4163 - Corner case in initializers.
#4360 - Fix constructor emission for parameterized types conforming to a trait composition.
#4362 - Function call with
IntLiteral incorrectly eliminated despite side-effects.
#4431 - [BUG] Python.evaluate doesn't handle null termination correctly.
#4492 - Fix
StringSlice.replace seg fault.
Special thanks to our community contributors:
@auris, @bgreni, @christianbator, @KamilGucik, @kasmith11, @martinvuyk, @ratulb, @rd4com, @sora, @thatstoasty, and @winding-lines.
]]>Check out the new GPU basics section of the Mojo Manual and the Get started with GPU programming with Mojo and the MAX Driver tutorial for a guide to getting started with GPU programming in Mojo!
Some APIs in the gpu package were enhanced to simplify
working with GPUs.
If you're executing a GPU kernel only once, you can now skip compiling it
first before enqueueing it, and pass it directly to
DeviceContext.enqueue_function().
The three separate methods on DeviceContext for asynchronously copying
buffers between host and GPU memory have been combined to single overloaded
enqueue_copy()
method, and the three separate methods for synchronous copies have been
combined into an overloaded
copy_sync()
method.
The gpu.shuffle module has been renamed to
gpu.warp to better reflect its purpose.
The gpu package API documentation has been expanded,
and API documentation for the layout package is
underway, beginning with core types, functions, and traits.
See the Standard library changes section of the changelog for more information.
The legacy borrowed/inout keywords and -> T as foo syntax are no longer
supported and now generate a compiler error. Please move to read/mut/out
argument syntax instead. See Argument
conventions in the Mojo
Manual for more information.
The standard library has many changes related to strings. Notably, the Char
type has been renamed to
Codepoint, to better
capture its intended purpose of storing a single Unicode codepoint.
Additionally, related method and type names have been updated as well. See
Standard library changes for more details.
Support has been added for 128- and 256-bit signed and unsigned integers. This
includes the DType aliases
DType.int128, DType.uint128, DType.int256, and DType.uint256, as well
as SIMD support for 128- and 256-bit
signed and unsigned element types. Note that this exposes capabilities (and
limitations) of LLVM, which may not always provide high performance for these
types and may have missing operations like divide, remainder, etc. See
Standard library changes for more details.
References to aliases in struct types with unbound (or partially) bound parameters sets are now allowed as long as the referenced alias doesn't depend on any unbound parameters:
struct StructWithParam[a: Int, b: Int]:
alias a1 = 42
alias a2 = a+1
fn test():
_ = StructWithParams.a1 # ok
_ = StructWithParams[1].a2 # ok
_ = StructWithParams.a2 # error, 'a' is unbound.
The Mojo compiler now warns about @parameter for with large loop unrolling
factor (>1024 by default), which can lead to long compilation time and large
generated code size. Set --loop-unrolling-warn-threshold to change default
value to a different threshold or to 0 to disable the warning.
The Mojo compile-time interpreter can now handle many more LLVM intrinsics,
including ones that return floating point values. This allows functions like
round() to be constant folded when used
in a compile-time context.
The Mojo compiler now has only one compile-time interpreter. It had two previously: one to handle a few cases that were important for dependent types in the parser (but which also had many limitations), and the primary one that ran at "instantiation" time which is fully general. This was confusing and caused a wide range of bugs. We've now removed the special case parse-time interpreter, replacing it with a more general solution for dependent types. This change should be invisible to most users, but should resolve a number of long-standing bugs and significantly simplifies the compiler implementation, allowing us to move faster.
Optional,
Span, and
InlineArray have been
added to the prelude. You now no longer need to explicitly import these types
to use them in your program.
GPU programming changes:
You can now skip compiling a GPU kernel first before enqueueing it, and pass
it directly to
DeviceContext.enqueue_function():
from gpu.host import DeviceContext
fn func():
print("Hello from GPU")
with DeviceContext() as ctx:
ctx.enqueue_function[func](grid_dim=1, block_dim=1)
However, if you're reusing the same function and parameters multiple times,
this incurs some overhead of around 50-500 nanoseconds per enqueue. So you
can still compile the function first with
DeviceContext.compile_function()
and pass it to DeviceContext.enqueue_function() like this:
with DeviceContext() as ctx:
var compiled_func = ctx.compile_function[func]()
# Multiple kernel launches with the same function/parameters
ctx.enqueue_function(compiled_func, grid_dim=1, block_dim=1)
ctx.enqueue_function(compiled_func, grid_dim=1, block_dim=1)
The following methods on
DeviceContext:
enqueue_copy_to_device()enqueue_copy_from_device()enqueue_copy_device_to_device()have been combined to a single overloaded
enqueue_copy()
method. Additionally, the methods:
copy_to_device_sync()copy_from_device_sync()copy_device_to_device_sync()have been combined into an overloaded
copy_sync()
method.
The gpu.shuffle module has been renamed to
gpu.warp to better reflect its purpose.
For example:
import gpu.warp as warp
var val0 = warp.shuffle_down(x, offset)
var val1 = warp.broadcast(x)
Support has been added for 128- and 256-bit signed and unsigned integers.
The following aliases have been added to the
DType struct: DType.int128,
DType.uint128, DType.int256, and DType.uint256.
The SIMD type now supports 128- and
256-bit signed and unsigned element types. Note that this exposes
capabilities (and limitations) of LLVM, which may not always provide high
performance for these types and may have missing operations like divide,
remainder, etc.
The following Scalar aliases for
1-element SIMD values have been added: Int128, UInt128, Int256, and
UInt256.
String and friends:
The Char type has been renamed to
Codepoint, to
better capture its intended purpose of storing a single Unicode codepoint.
Additionally, related method and type names have been updated as well,
including:
StringSlice.chars() and String.chars() to
StringSlice.codepoints()
and
String.codepoints(),
respectively
StringSlice.char_slices() and String.char_slices() to
StringSlice.codepoint_slices()
and
String.codepoint_slices(),
respectively
CharsIter to
CodepointsIter
Char.unsafe_decode_utf8_char() to
Codepoint.unsafe_decode_utf8_codepoint()
Made the iterator type returned by the string codepoint_slices() methods
public as
CodepointSliceIter.
StringSlice
now supports several additional methods moved from
String. The existing
String methods have been updated to instead call the corresponding new
StringSlice methods:
Added a
StringSlice.is_codepoint_boundary()
method for querying if a given byte index is a boundary between encoded
UTF-8 codepoints.
StringSlice.__getitem__(Slice)
now raises an error if the provided slice start and end positions do not
fall on a valid codepoint boundary. This prevents construction of malformed
StringSlice values, which could lead to memory unsafety or undefined
behavior. For example, given a string containing multi-byte encoded data,
like:
str_slice = "Hi👋!"
and whose in-memory and decoded data looks like:
| String | Hi👋! | ||||||
| Codepoint Characters | H | i | 👋 | ! | |||
| Codepoints | 72 | 105 | 128075 | 33 | |||
| Bytes | 72 | 105 | 240 | 159 | 145 | 139 | 33 |
| Index | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
attempting to slice bytes [3-5) with str_slice[3:5] would previously
erroneously produce a malformed StringSlice as output that did not
correctly decode to anything:
| String | invalid | |
| Codepoint Characters | invalid | |
| Codepoints | invalid | |
| Bytes | 159 | 145 |
| Index | 0 | 1 |
The same statement will now raise an error informing the user that their indices are invalid.
The StringLiteral.get[value]() method, which converts a compile-time value
of Stringable type has been changed
to a function named
get_string_literal[value]().
Collections:
A new IntervalTree data
structure has been added to the standard library. This is a tree data
structure that allows for efficient range queries.
Added an iterator to
LinkedList (PR
#4005)
LinkedList.__iter__()
to create a forward iterator.
LinkedList.__reversed__()
for a backward iterator.
var ll = LinkedList[Int](1, 2, 3)
for element in ll:
print(element[])
List.bytecount() has been renamed to
List.byte_length() for
consistency with the string-like APIs.
The
InlineArray(unsafe_uninitialized=True)
constructor is now spelled InlineArray(uninitialized=True).
The design of the IntLiteral
and FloatLiteral types
has been changed to maintain their compile-time-only value as a parameter
instead of a stored field. This correctly models that infinite precision
literals are not representable at runtime, and eliminates a number of bugs hit
in corner cases. This is made possible by enhanced dependent type support in
the compiler.
The Buffer struct has been removed in favor of
Span and NDBuffer.
The round() function is now fixed to
perform "round half to even" (also known as "bankers' rounding") instead of
"round half away from zero".
The
UnsafePointer.alloc()
method has changed to produce pointers with an empty Origin parameter,
instead of with MutableAnyOrigin. This mitigates an issue with the any
origin parameter extending the lifetime of unrelated local variables for this
common method.
Several more packages are now documented:
Added a new sys.is_compile_time() function. This enables you to query
whether code is being executed at compile time or not. For example:
from sys import is_compile_time
fn check_compile_time() -> String:
if is_compile_time():
return "compile time"
else:
return "runtime"
def main():
alias var0 = check_compile_time()
var var1 = check_compile_time()
print("var0 is evaluated at ", var0, " , while var1 is evaluated at ", var1)
will print
var0 is evaluated at compile time, while var1 is evaluated at runtime.
Mojo API documentation generation is now able to display function and struct parameter references inside nested parametric types using names instead of indices. For example, instead of
sort[type: CollectionElement, //, cmp_fn: fn($1|0, $1|0) capturing -> Bool](span: Span[type, origin])
it now displays
sort[type: CollectionElement, //, cmp_fn: fn(type, type) capturing -> Bool](span: Span[type, origin])
Use of legacy argument conventions like inout and the use of as in named
results now produces an error message instead of a warning.
Direct access to List.size has been removed. Use the public API instead.
Examples:
Extending a List:
base_data = List[Byte](1, 2, 3)
data_list = List[Byte](4, 5, 6)
ext_data_list = base_data.copy()
ext_data_list.extend(data_list) # [1, 2, 3, 4, 5, 6]
data_span = Span(List[Byte](4, 5, 6))
ext_data_span = base_data.copy()
ext_data_span.extend(data_span) # [1, 2, 3, 4, 5, 6]
data_vec = SIMD[DType.uint8, 4](4, 5, 6, 7)
ext_data_vec_full = base_data.copy()
ext_data_vec_full.extend(data_vec) # [1, 2, 3, 4, 5, 6, 7]
ext_data_vec_partial = base_data.copy()
ext_data_vec_partial.extend(data_vec, count=3) # [1, 2, 3, 4, 5, 6]
Slicing and extending a list efficiently:
base_data = List[Byte](1, 2, 3, 4, 5, 6)
n4_n5 = Span(base_data)[3:5]
extra_data = Span(List[Byte](8, 10))
end_result = List[Byte](capacity=len(n4_n5) + len(extra_data))
end_result.extend(n4_n5)
end_result.extend(extra_data) # [4, 5, 8, 10]
InlinedFixedVector and InlineList have been removed. Instead, use
InlineArray when the
upper bound is known at compile time. If the upper bound is not known until
runtime, use List with the capacity
constructor to minimize allocations.
variance
argument in random.randn_float64()
and random.randn() has been renamed to
standard_deviation so that values are drawn from the correct distribution.Special thanks to our community contributors: @bgreni, @fnands, @illiasheshyn, @izo0x90, @lydiandy, @martinvuyk, @msaelices, @owenhilyard, @rd4com, @yinonburgansky
]]>The legacy borrowed/inout keywords and -> T as foo syntax are deprecated
and now generate a compiler warning. Please move to read/mut/out
argument syntax instead. See
Argument conventions
in the Mojo Manual for more information.
The bool(), float(), int(), and str() functions are deprecated and
generate compiler warnings. Please use the Bool(), Float64(), Int(), and
String() constructors instead. See Standard library
changes for more details.
The standard library has many changes related to strings. The new
Char struct
represents a single Unicode character, and includes several methods for
categorizing character types. When iterating over the characters of a String
with a for loop, you now should use the
String.chars() method
to provide an iterator of Char values or the
String.char_slices()
method to provide an iterator of
StringSlice
instances for each character. StringRef has been removed in favor of
StringSlice.
And various functionality has moved from String and StringLiteral to the
more general StringSlice type. See Standard library
changes for more details.
You can now use SIMD constructors to cast
existing SIMD values (including Scalar values) to a different type, though
you can still use the SIMD.cast()
method to infer the size of the new vector. See Standard library
changes for more details.
The legacy borrowed/inout keywords and -> T as foo syntax now generate
a warning. Please move to read/mut/out argument syntax instead. See
Argument conventions
in the Mojo Manual for more information.
Initializers are now treated as static methods that return an instance of
Self. This means the out argument of an initializer is now treated the
same as any other function result or out argument. This is generally
invisible, except that patterns like instance.__init__() and
x.__copyinit__(y) no longer work. Simply replace them with instance = T()
and x = y respectively.
The @value decorator now additionally
derives an implementation of the ExplicitlyCopyable trait.
This will ease the transition to explicit copyability requirements by default
in the Mojo collection types.
Indexing into a homogenous tuple now produces the consistent element type without needing a rebind:
var x = (1, 2, 3, 3, 4)
var y : Int = x[idx] # Just works!
You can now overload positional arguments with a keyword-only argument, and keyword-only arguments with different names:
struct OverloadedKwArgs:
var val: Int
fn __init__(out self, single: Int):
self.val = single
fn __init__(out self, *, double: Int):
self.val = double * 2
fn __init__(out self, *, triple: Int):
self.val = triple * 3
fn main():
OverloadedKwArgs(1) # val=1
OverloadedKwArgs(double=1) # val=2
OverloadedKwArgs(triple=2) # val=6
This also works with indexing operations:
struct OverloadedKwArgs:
var vals: List[Int]
fn __init__(out self):
self.vals = List[Int](0, 1, 2)
fn __getitem__(self, idx: Int) -> Int:
return self.vals[idx]
fn __getitem__(self, *, idx2: Int) -> Int:
return self.vals[idx2 * 2]
fn __setitem__(mut self, idx: Int, val: Int):
self.vals[idx] = val
fn __setitem__(mut self, val: Int, *, idx2: Int):
self.vals[idx2 * 2] = val
fn main():
var x = OverloadedKwArgs()
print(x[1]) # 1
print(x[idx2=1]) # 2
x[1] = 42
x[idx2=1] = 84
print(x[1]) # 42
print(x[idx2=1]) # 84
The __disable_del x operation has been tightened up to treat all fields of
x as consumed by the point of the deletion, so it should be used after all
the subfields are transferred or otherwise consumed (for example, at the end
of the function), not before uses of the fields.
The new gpu package provides low-level programming
constructs for working with GPUs. The Mojo gpu APIs allow you to manually
manage interaction between the CPU host and GPU device, manage memory between
devices, synchronize threads, and more. Currently the best way to use these
APIs is from inside a MAX custom operation.
The following code example shows a GPU kernel written in Mojo:
from max.tensor import ManagedTensorSlice
from gpu import thread_idx, block_dim, block_idx
fn gpu_add_kernel(out: ManagedTensorSlice, x: ManagedTensorSlice[out.type, out.rank]):
tid_x = thread_idx.x + block_dim.x * block_idx.x
tid_y = thread_idx.y + block_dim.y * block_dim.y
if tid_x < x.dim_size(0) and tid_y < x.dim_size(1):
out[tid_x, tid_y] = x[tid_x, tid_y] + 1
The example above includes only the actual kernel code that’s run on the GPU,
not the code to define a custom operation or launch the kernel. For more
complete examples, see
vector_addition.mojo
and
top_k.mojo.
The layout package includes APIs for working with
layouts, which describe the organization of a tensor (for example, row-major
or column-major layout), and the
LayoutTensor type, which
represents a tensor with a specified layout. The layout package can be used
to build efficient tensor operations that run on a GPU.
We’ll continue adding code examples and documentation for the gpu and
layout packages in future releases.
The builtin functions for converting values to different types have been deprecated for actual constructors:
| Before | After |
|---|---|
bool() | Bool() |
float() | Float64() |
int() | Int() |
str() | String() |
These functions were a workaround before Mojo had a way to distinguish between
implicit and explicit constructors. For this release you'll get a deprecation
warning, and in the next release they'll become compiler errors. You can
quickly update your code by doing a Match Case and Match Whole Word
search and replace for int( to Int( etc.
String and friends:
Added Char for
representing and storing single Unicode characters.
Char implements
CollectionElement,
EqualityComparable,
Intable, and
Stringable.
Char provides methods for categorizing character types, including:
Char.is_ascii(),
Char.is_ascii_digit(),
Char.is_ascii_upper(),
Char.is_ascii_lower(),
Char.is_ascii_printable(),
Char.is_posix_space(),
Char.is_python_space().
Added a String() constructor from Char.
Char can be converted to UInt32 via
Char.to_u32().
chr() will now abort if
given a codepoint value that is not a valid Char.
StringRef has been removed in favor of
StringSlice.
The two types are ABI compatible, and for the exact same behavior one can
use StaticString, which is an alias to
StringSlice[StaticConstantOrigin].
Various functionality has moved from String and StringLiteral to the
more general StringSlice type.
Added
StringSlice.from_utf8()
factory method, for validated construction of a StringSlice from a buffer
containing UTF-8 encoded data. This method will raise if the buffer contents
are not valid UTF-8.
Added
StringSlice.chars()
which returns an iterator over Chars. This is a compliant UTF-8 decoder
that returns each Unicode codepoint encoded in the string.
Added
StringSlice.__getitem__(Slice)
which returns a substring. Only step sizes of 1 are supported.
Several standard library functions have been changed to take StringSlice
instead of String. This generalizes them to be used for any appropriately
encoded string in memory, without requiring that the string be heap
allocated. This includes:
ascii(),
atol(),
atof(),
b16decode(),
b16encode(),
b64decode(),
b64encode(), and
ord().
Added new
String.chars() and
String.char_slices()
iterator methods, and deprecated the existing String.__iter__() method.
Different use-cases may prefer iterating over the Chars encoded in a
string, or iterating over subslices containing single characters. Neither
iteration semantics is an obvious default, so the existing __iter__()
method has been deprecated in favor of writing explicit iteration methods
for the time being.
Code of the form:
var s: String = ...
for c in s:
# ...
can be migrated to using the .char_slices() method:
var s: String = ...
for c in s.char_slices():
# ...
Added
StringSlice.char_length()
method, to pair with the existing
StringSlice.byte_length()
method.
The
String.__len__()
and
StringSlice.__len__()
methods now return the length of the string in bytes.
Previously, these methods were documented to note that they would eventually return a length in Unicode codepoints. They have been changed to guarantee a length in bytes, since the length in bytes is how they are most often used today (for example, as bounds to low-level memory manipulation logic). Additionally, length in codepoints is a more specialized notion of string length that is rarely the correct metric.
Users that know they need the length in codepoints can use the
str.char_length() method, or len(str.chars()).
StringSlice now implements
Representable, and that
implementation is now used by String.__repr__() and
StringLiteral.__repr__().
StringSlice now implements
EqualityComparable.
Up until now, StringSlice has implemented a more general __eq__() and
__ne__() comparison with StringSlice types that had arbitrary other
origins. However, to satisfy EqualityComparable, StringSlice now also
has narrower comparison methods that support comparing only with another
StringSlice with the exact same origin.
The String.write() static method has moved to a String() constructor,
and is now buffered. Instead of doing:
var msg = "my message " + String(x) + " " + String(y) + " " + String(z)
Which reallocates the String you should do:
var msg = String("my message", x, y, z, sep=" ")
Which is cleaner, and buffers to the stack so the String is allocated only
once.
You can now pass any Writer to
write_buffered():
from utils.write import write_buffered
var string = String("existing string")
write_buffered(string, 42, 42.4, True, sep=" ")
This writes to a buffer on the stack before reallocating the String.
Collections:
A new LinkedList type
has been added to the standard library.
Added
Optional.copied() for
constructing an owned Optional[T] from an Optional[Pointer[T]] by
copying the pointee value.
Added Dict.get_ptr() which
returns an Optional[Pointer[V]]. If the given key is present in the
dictionary, the optional will hold a pointer to the value. Otherwise, an
empty optional is returned.
Added new List.extend()
overloads taking SIMD and
Span. These enable growing a
List[Scalar[..]] by copying the elements of a SIMD vector or
Span[Scalar[..]], simplifying the writing of some optimized SIMD-aware
functionality.
UnsafePointer changes:
UnsafePointer's bitcast() method has now been split into
bitcast() for
changing the type,
origin_cast()
for changing mutability,
static_alignment_cast()
for changing alignment, and
address_space_cast()
for changing the address space.
UnsafePointer is now parameterized on mutability. Previously,
UnsafePointer could only represent mutable pointers.
The new mut parameter can be used to restrict an UnsafePointer to a
specific mutability: UnsafePointer[T, mut=False] represents a pointer to
an immutable T value. This is analogous to a const * pointer in C++.
UnsafePointer.address_of()
will now infer the origin and mutability of the resulting pointer from the
argument. For example:
var local = 10
# Constructs a mutable pointer, because `local` is a mutable memory location
var ptr = UnsafePointer.address_of(local)
To force the construction of an immutable pointer to an otherwise mutable memory location, use a cast:
var local = 10
# Cast the mutable pointer to be immutable.
var ptr = UnsafePointer.address_of(local).origin_cast[mut=False]()
The unsafe_ptr() method on several standard library collection types have
been updated to use parametric mutability: they will return an
UnsafePointer whose mutability is inherited from the mutability of the
ref self of the receiver at the call site. For example, ptr1 will be
immutable, while ptr2 will be mutable:
fn take_lists(read list1: List[Int], mut list2: List[Int]):
# Immutable pointer, since receiver is immutable `read` reference
var ptr1 = list1.unsafe_ptr()
# Mutable pointer, since receiver is mutable `mut` reference
var ptr2 = list2.unsafe_ptr()
New and updated traits:
The ExplicitlyCopyable
trait has changed to require a fn copy(self) -> Self method. Previously,
an initializer with the signature fn __init__(out self, *, other: Self)
had been required by ExplicitlyCopyable.
This improves the "greppability" and at-a-glance readability when a programmer is looking for places in their code that may be performing copies.
The IntLike trait has been removed and its functionality incorporated into
the Indexer trait. This enables
SIMD scalar integer types and UInt to be used for indexing into all of
the collection types, as well as optimizing away normalization checks for
UInt indexing.
The ImplicitlyIntable trait
has been added, allowing types to be implicitly converted to an Int by
implementing the __as_int__() method:
@value
struct Foo(ImplicitlyIntable):
var i: Int
fn __as_int__(self) -> Int:
return self.i
You can now cast SIMD types using constructors:
var val = Int8(42)
var cast = Int32(val)
It also works when passing a scalar type to larger vector size:
var vector = SIMD[DType.int64, 4](cast) # [42, 42, 42, 42]
For values other than scalars the size of the SIMD vector needs to be equal:
var float_vector = SIMD[DType.float64, 4](vector)
SIMD.cast() still exists to infer the
size of new vector:
var inferred_size = float_vector.cast[DType.uint64]() # [42, 42, 42, 42]
Added SIMD.from_bytes() and
SIMD.as_bytes() to convert a
list of bytes to a list of scalars and vice versa, accepting the endianness as
an argument. Similar to Python int.from_bytes() and int.to_bytes()
functions.
You can now use max() and
min() with variadic number of arguments.
bit_ceil() has been renamed to
next_power_of_two(), and
bit_floor() to
prev_power_of_two(). This is to
improve readability and clarity in their use.
Added a new boolean validate parameter to
b64decode().
The b64encode() overload that
previously took a List has been changed to take a
Span.
Removed the @implicit decorator from some standard library initializer
methods that perform allocation. This reduces places where Mojo code could
implicitly allocate where the user may not be aware.
Removed @implicit from:
String.__init__(out self, StringSlice)List.__init__(out self, owned *values: T)List.__init__(out self, span: Span[T])Added more aliases in sys.ffi to round out the
usual needs for FFI bindings.
mblack (aka mojo format) no longer formats non-Mojo
files. This prevents unexpected formatting of Python files.
Full struct signature information is now exposed in the documentation generator, and in the symbol outline and hover markdown via the Mojo Language Server.
The env_get_dtype() function has
been added to the sys.param_env module. This
allows you to get the value of a DType from the param environment.
StringRef has been removed. Use
StringSlice
instead.
Changed sys.argv() to return list of
StringSlice.
Added explicit Path()
constructor from StringSlice.
The Tuple.get[i, T]() method has been removed. Please use tup[i] or
rebind[T](tup[i]) as needed instead.
StringableCollectionElement is deprecated. Use WritableCollectionElement
instead, which still allows you to construct a String, but can avoid
intermediate allocations.
The IntLike trait has been removed and its functionality incorporated into
the Indexer trait.
The Type{field1: 42, field2: 17} syntax for direct initializing register
passable types has been removed. This was legacy syntax - to upgrade your
code, add the @value decorator to your
struct to get a fieldwise initializer and use Type(field1=42, field2 = 17)
instead.
The Mojo Kernel for Jupyter Notebooks is working again on nightly releases.
The command mojo debug --vscode now sets the current working directory
properly.
Issue #3796 - Compiler crash
handling for-else statement.
Issue #3540 - Using named output slot breaks trait conformance
Issue #3617 - Can't generate
the constructors for a type wrapping !lit.ref
The Mojo Language Server doesn't crash anymore on empty __init__.mojo files.
Issue #3826.
Issue #3935 - Confusing OOM
error when using Tuple.get() incorrectly.
Issue #3955 - Unexpected
copy behavior with def arguments in loops
Issue #3960 - Infinite for
loop
Here's a brief summary of some of the major changes in this release, with more detailed information in the following sections:
The inout and borrowed argument conventions have been renamed to mut
and read, respectively. A new out convention has been added for the self
argument in constructors and for named results. See
Language changes for details.
Lifetime and related types in the standard library have been renamed to
Origin to better clarify that
parameters of this type indicate where a reference is derived from, not the
more complicated notion of where a variable is initialized and destroyed. As a
consequence the __lifetime_of() operator is now named __origin_of().
There are also a number of other origin-related improvements in this release,
including being able to specify a union of origins by listing multiple values
in the __origin_of() operator or inside the ref origin specifier
(ref [a, b]). For details, see Language changes.
For background information and rationale on the name change see the proposal. For more information on origins, see Lifetimes, origins and references in the Mojo Manual.
Implicit conversions are now opt-in using the
@implicit decorator. See
Language changes for details.
The standard library has added several new types, including
Deque (a double-ended queue) and
OwnedPointer (safe,
single-owner, non-nullable smart pointer). See
Standard library changes
for details.
The VS Code extension now supports setting data breakpoints and function
breakpoints, and the Mojo LLDB debugger supports symbol breakpoints, such
as b main or b my_module::main.
We've made a number of improvement to how information is displayed in error messages, LSP, and generated API documentation. For details, see Tooling changes.
And we've added a number of new docs, including a brand new Mojo tutorial, new pages on operators and expressions, error handling, and pointers, and many smaller additions and improvements.
Argument convention changes:
The inout and borrowed argument conventions have been renamed to mut
(for "mutate") and read, respectively. These verbs reflect what the callee
can do to the argument value passed in by the caller, without requiring the
programmer to know about advanced features like references.
For information on Mojo's argument conventions, see Argument conventions in the Mojo Manual.
The argument convention for the self argument in the __init__(),
__copyinit__(), and __moveinit__() methods has been changed from inout
to out, reflecting that a constructor method initializes its self value
without reading from it. This also enables spelling the type of an
initializer correctly, which was not supported before:
struct Foo:
fn __init__(out self): pass
fn test():
# This works now
var fnPtr : fn(out x: Foo)->None = Foo.__init__
var someFoo : Foo
fnPtr(someFoo) # initializes someFoo.
The previous fn __init__(inout self) syntax is still supported in this
release of Mojo, but will be removed in the future. Please migrate to the
new syntax.
Similarly, the spelling of named results has switched to use
out syntax instead of -> T as name. Functions may have at most one named
result or return type specified with the usual -> syntax. out arguments
may occur anywhere in the argument list, but are typically last (except for
__init__ methods, where they are typically first).
# This function has type "fn() -> String"
fn example(out result: String):
result = "foo"
The parser still accepts the old syntax as a synonym for this, but that will eventually be deprecated and removed.
This was discussed extensively in a public proposal. For more information, see Named results in the Mojo Manual.
Single argument constructors now require the
@implicit decorator to allow for
implicit conversions. Previously you could define an __init__ that takes a
single argument:
struct Foo:
var value: Int
fn __init__(out self, value: Int):
self.value = value
And this would allow you to pass an Int in the position of a Foo:
fn func(foo: Foo):
print("implicitly converted Int to Foo:", foo.value)
fn main():
func(Int(42))
This can result in complicated errors that are difficult to debug. By default
this implicit behavior is now turned off, so you have to explicitly construct
Foo:
fn main():
func(Foo(42))
You can still opt into implicit conversions by adding the @implicit
decorator. For example, to enable implicit conversions from Int to Foo:
struct Foo:
var value: Int
@implicit
fn __init__(out self, value: Int):
self.value = value
For more information see Constructors and implicit conversion in the Mojo Manual.
Origin-related changes:
The AnyLifetime type (useful for declaring origin types as parameters) has
has been renamed to Origin and
the __lifetime_of() operator renamed to __origin_of().
Origin is now a complete wrapper around the MLIR origin type.
The Origin.type alias has been renamed to _mlir_origin. In parameter
lists, you can now write just Origin[..], instead of Origin[..].type.
ImmutableOrigin and MutableOrigin are now, respectively, just aliases
for Origin[False] and Origin[True].
Origin struct values are now supported in the origin specifier of a
ref [..] argument.
Added Origin.cast_from for casting the mutability of an origin value.
ref arguments and results now allow for providing a memory value
directly in the origin specifier, rather than requiring the use of
__origin_of(). It is still fine to use __origin_of() explicitly though,
and this is required when specifying origins for parameters (e.g. to the
Pointer type). For example, this is now valid without __origin_of():
fn return_ref(a: String) -> ref [a] String:
return a
Various improvements to origin handling and syntax have landed, including
support for the ternary operator and allowing multiple arguments in a ref
specifier (which are implicitly unions). This enables expression of simple
algorithms cleanly:
fn my_min[T: Comparable](ref a: T, ref b: T) -> ref [a, b] T:
return a if a < b else b
It is also nice that my_min automatically and implicitly propagates the
mutability of its arguments, so things like my_min(str1, str2) += "foo" is
valid.
ref function arguments without an origin clause are now treated as
ref [_], which is more syntactically convenient and consistent:
fn takes_and_return_ref(ref a: String) -> ref [a] String:
return a
The __type_of(x) and __origin_of(x) operators are much more general now:
they allow arbitrary expressions inside of them, allow referring to dynamic
values in parameter contexts, and even allow referring to raising functions
in non-raising contexts. These operations never evaluate their expression,
so any side effects that occur in the expression are never evaluated at
runtime, eliminating concerns about __type_of(expensive()) being a
problem.
The destructor insertion logic in Mojo is now aware that types that take an
MutableAnyOrigin or ImmutableAnyOrigin as part of their signature could
potentially access any live value that destructor insertion is tracking,
eliminating a significant usability issue with unsafe APIs like
UnsafePointer.
Consider a typical example working with strings before this change:
var str = String(...)
var ptr = str.unsafe_ptr()
some_low_level_api(ptr)
_ = str^ # OLD HACK: Explicitly keep string alive until here!
The _ = str^ pattern was formerly required because the Mojo compiler has
no idea what "ptr" might reference. As a consequence, it had no idea that
some_low_level_api() might access str and therefore thought it was ok to
destroy the String before the call - this is why the explicit lifetime
extension was required.
Mojo now knows that
UnsafePointer may
access the MutableAnyOrigin origin, and now assumes that any API that uses
that origin could use live values. In this case, it assumes that
some_low_level_api() might access str and because it might be using it,
it cannot destroy str until after the call. The consequence of this is
that the old hack is no longer needed for these cases!
Function types now accept an origin set parameter. This parameter represents the origins of values captured by a parameter closure. The compiler automatically tags parameter closures with the right set of origins. This enables lifetimes and parameter closures to correctly compose.
fn call_it[f: fn() capturing [_] -> None]():
f()
fn test():
var msg = String("hello world")
@parameter
fn say_hi():
print(msg)
call_it[say_hi]()
# no longer need to write `_ = msg^`!!
Note that this only works for higher-order functions which have explicitly
added [_] as the capture origins. By default, the compiler still assumes
a capturing closure does not reference any origins. This will soon change.
Infer-only parameters may now be explicitly bound with keywords, enabling some important patterns in the standard library:
struct StringSlice[is_mutable: Bool, //, origin: Origin[is_mutable]]: ...
alias ImmStringSlice = StringSlice[is_mutable=False]
# This auto-parameterizes on the origin, but constrains it to being an
# immutable slice instead of a potentially mutable one.
fn take_imm_slice(a: ImmStringSlice): ...
The flag for turning on asserts has changed, e.g. to enable all checks:
mojo -D ASSERT=all main.mojo
The levels are:
none: all assertions offwarn: print assertion errors e.g. for multithreaded tests (previously -D ASSERT_WARNING)safe: the default mode for standard CPU safety assertionsall: turn on all assertions (previously -D MOJO_ENABLE_ASSERTIONS)You can now also pass Stringable args to format a message, which will have
no runtime penalty or IR bloat cost when assertions are off. Previously you
had to:
x = -1
debug_assert(
x > 0, String.format_sequence(“expected x to be more than 0 but got: ”, x)
)
Which can't be optimized away by the compiler in release builds, you can now pass multiple args for a formatted message at no runtime cost:
debug_assert(x > 0, “expected x to be more than 0 but got: ”, x)
Automatic parameterization of parameters is now supported. Specifying a parameterized type with unbound parameters causes them to be implicitly added to the function signature as infer-only parameters.
fn foo[value: SIMD[DType.int32, _]]():
pass
# Equivalent to
fn foo[size: Int, //, value: SIMD[DType.int32, size]]():
pass
Mojo can now interpret simple LLVM intrinsics in parameter expressions,
enabling things like count_leading_zeros to work at compile time:
Issue #933.
Introduced the @explicit_destroy annotation, the __disable_del keyword,
the UnknownDestructibility trait, and the ImplicitlyDestructible keyword,
for the experimental explicitly destroyed types feature.
Added associated types; we can now have aliases like alias T: AnyType,
alias N: Int, etc. in a trait, and then specify them in structs that conform
to that trait. For more information, see Associated aliases for
generics.
Introduced a new Deque (double-ended
queue) collection type, based on a dynamically resizing circular buffer for
efficient O(1) additions and removals at both ends as well as O(1) direct
access to all elements.
The Deque supports the full Python collections.deque API, ensuring that
all expected deque operations perform as in Python.
Enhancements to the standard Python API include peek() and peekleft()
methods for non-destructive access to the last and first elements, and
advanced constructor options (capacity, min_capacity, and shrink) for
customizing memory allocation and performance. These options allow for
optimized memory usage and reduced buffer reallocations, providing flexibility
based on application requirements.
The Formatter struct has been replaced with a
Writer trait to enable buffered IO,
increasing print and file writing perf to the same speed as C. It's now more
general purpose and can write any Span[Byte]. To align with this the
Formattable trait is now named
Writable, and the
String.format_sequence() static method to initialize a new String has been
renamed to
String.write().
Here's an example of using all of the changes:
from memory import Span
@value
struct NewString(Writer, Writable):
var s: String
# Writer requirement to write a Span of Bytes
fn write_bytes(inout self, bytes: Span[Byte, _]):
self.s._iadd[False](bytes)
# Writer requirement to take multiple args
fn write[*Ts: Writable](inout self, *args: *Ts):
@parameter
fn write_arg[T: Writable](arg: T):
arg.write_to(self)
args.each[write_arg]()
# Also make it Writable to allow `print` to write the inner String
fn write_to[W: Writer](self, inout writer: W):
writer.write(self.s)
@value
struct Point(Writable):
var x: Int
var y: Int
# Pass multiple args to the Writer. The Int and StringLiteral types call
# `writer.write_bytes` in their own `write_to` implementations.
fn write_to[W: Writer](self, inout writer: W):
writer.write("Point(", self.x, ", ", self.y, ")")
# Enable conversion to a String using `str(point)`
fn __str__(self) -> String:
return String.write(self)
fn main():
var point = Point(1, 2)
var new_string = NewString(str(point))
new_string.write("\n", Point(3, 4))
print(new_string)
Point(1, 2)
Point(3, 4)
The TypeIdentifiable trait has been removed in favor of the new
get_type_name utility in the compile.reflection module.
Python interop changes:
Introduced
TypedPythonObject
as a light-weight way to annotate
PythonObject values with
static type information. This design will likely evolve and change
significantly.
TypedPythonObject[Tuple].__getitem__() for accessing the elements
of a Python tuple.Added
Python.add_object(), to
add a named PythonObject value to a Python 'module' object instance.
Added
Python.unsafe_get_python_exception(),
as an efficient low-level utility to get the Mojo Error equivalent of the
current CPython error state.
Add
PythonObject.from_borrowed_ptr(),
to simplify the construction of PythonObject values from CPython 'borrowed
reference' pointers.
The existing PythonObject.__init__(PyObjectPtr) should continue to be used
for the more common case of constructing a PythonObject from a 'strong
reference' pointer.
Support for multi-dimensional indexing and slicing for PythonObject
(PR #3549,
PR #3583).
var np = Python.import_module("numpy")
var a = np.array(PythonObject([1,2,3,4,5,6])).reshape(2,3)
print((a[0, 1])) # 2
print((a[1][::-1])) # [6 5 4]
Note that the syntax, a[1, ::-1], is currently not supported.
Added
PythonObject.__contains__().
(PR #3101)
Example usage:
x = PythonObject([1,2,3])
if 1 in x:
print("1 in x")
Pointer related changes:
The UnsafePointer type
now has an origin parameter that can be used when the UnsafePointer
points to a value with a known origin. This origin is propagated through the
ptr[] indirection operation. This parameter and other UnsafePointer
parameters (other than the type) are now keyword-only.
You can now index into UnsafePointer using SIMD scalar integral types:
p = UnsafePointer[Int].alloc(1)
i = UInt8(1)
p[i] = 42
print(p[i])
Added a new OwnedPointer
type as a safe, single-owner, non-nullable smart pointer with similar
semantics to Rust's
Box<> and C++'s
std::unique_ptr.
(PR #3524)
Arc has been renamed to
ArcPointer, for consistency
with OwnedPointer.
ArcPointer now implements
Identifiable, and can be
compared for pointer equivalence using a is b.
The Reference type has been renamed to
Pointer: a memory safe complement
to UnsafePointer. This change is motivated by the fact that Pointer is
assignable and requires an explicit dereference with ptr[]. Renaming to
Pointer clarifies that "references" means ref arguments and results, and
gives us a model that is more similar to what the C++ community would
expect.
For an overview of Mojo's pointer types, see the new Intro to pointers page in the Mojo Manual.
A new
as_noalias_ptr()
method as been added to UnsafePointer. This method specifies to the
compiler that the resultant pointer is a distinct identifiable object that
does not alias any other memory in the local scope.
Added the Floatable and
FloatableRaising traits
to denote types that can be converted to a Float64 value using the builtin
float function. Made SIMD and FloatLiteral conform to the Floatable
trait. (PR #3163)
fn foo[F: Floatable](v: F):
...
var f = float(Int32(45))
The rebind() standard library function
now works with memory-only types in addition to
@register_passable("trivial") ones, without requiring a copy. For more
information, see
The rebind() builtin in the
Mojo Manual.
Introduced the random.shuffle()
function for randomizing the elements of a List.
(PR #3327)
Example:
from random import shuffle
var l = List[Int](1, 2, 3, 4, 5)
shuffle(l)
The Dict.__getitem__()
method now returns a reference instead of a copy of the value (or raises).
This improves the performance of common code that uses Dict by allowing
borrows from the Dict elements.
Slice.step is now an
Optional[Int], matching the optionality of slice.step in Python.
(PR #3160)
There is now a Byte alias to better
express intent when working with a pack of bits.
(PR #3670).
Expanded os.path with new functions:
Added a reserve()
method and new constructor to the String struct to allocate additional
capacity. (PR #3755).
A new
StringLiteral.get[some_stringable]()
method is available. It allows forming a runtime-constant StringLiteral from
a compile-time-dynamic Stringable value.
Span has moved from the utils module to
the memory module.
Span now implements __reversed__(). This
means that one can get a reverse iterator over a Span using
reversed(my_span). Users should currently prefer this method over
my_span[::-1].
A new AsBytes trait has been added to
enable taking a Span[Byte] from any type that implements as_bytes().
String.as_bytes() and String.as_bytes_slice() have been consolidated under
String.as_bytes() to return a Span[Byte]. If you require a copy, you can
convert the Span to a List with List(my_string.as_bytes()).
StringSlice now
implements strip(), rstrip(), and lstrip().
StringRef now
implements split() which can be used to split a StringRef into a
List[StringRef] by a delimiter. (PR
#2705)
StringRef is now
representable so repr(StringRef("hello")) will return StringRef('hello').
More things have been removed from the auto-exported set of entities in the
prelude module from the Mojo standard library:
UnsafePointer has been removed. Please explicitly import it via
from memory import UnsafePointer.StringRef has been removed. Please explicitly import it via
from utils import StringRef.Restored implicit copyability of Tuple
and ListLiteral.
The
aliases for C foreign function interface (FFI)
have been renamed: C_int -> c_int, C_long -> c_long and so on.
Float32 and Float64 are now printed and converted to strings with
roundtrip guarantee and shortest representation:
Value Old New
Float64(0.3) 0.29999999999999999 0.3
Float32(0.3) 0.30000001192092896 0.3
Float64(0.0001) 0.0001 0.0001
Float32(0.0001) 9.9999997473787516e-05 0.0001
Float64(-0.00001) -1.0000000000000001e-05 -1e-05
Float32(-0.00001) -9.9999997473787516e-06 -1e-05
Float32(0.00001234) 1.2339999557298142e-05 1.234e-05
Float32(-0.00000123456) -1.2345600453045336e-06 -1.23456e-06
Float64(1.1234567e-320) 1.1235052786429946e-320 1.1235e-320
Float64(1.234 * 10**16) 12340000000000000.0 1.234e+16
The StaticIntTuple data structure in the utils package has been renamed to
IndexList. The data structure now
allows one to specify the index bitwidth of the elements along with whether
the underlying indices are signed or unsigned.
Added DLHandle.get_symbol(), for
getting a pointer to a symbol in a dynamic library. This is more general
purpose than the existing methods for getting function pointers.
The VS Code Mojo Debugger now has a buildArgs JSON debug configuration
setting that can be used in conjunction with mojoFile to define the build
arguments when compiling the Mojo file.
The VS Code extension now supports a Configure Build and Run Args command
that helps set the build and run args for actions file Run Mojo File and
Debug Mojo File. A corresponding button appears in Run and Debug selector
in the top right corner of a Mojo File.
The VS Code extension now has the mojo.run.focusOnTerminalAfterLaunch
setting, which controls whether to focus on the terminal used by the
Mojo: Run Mojo File command or on the editor after launch.
Issue #3532.
The VS Code extension now has the mojo.SDK.additionalSDKs setting, which
allows the user to provide a list of MAX SDKs that the extension can use when
determining a default SDK to use. The user can select the default SDK to use
with the Mojo: Select the default MAX SDK command.
The VS Code extension now supports setting data breakpoints as well as function breakpoints.
The Mojo LLDB debugger now supports symbol breakpoints, for example, b main
or b my_module::main.
Error messages that include type names no longer include inferred or defaulted parameters when they aren't needed. For example, previously Mojo complained about things like:
... cannot be converted from 'UnsafePointer[UInt, 0, _default_alignment::AnyType](), MutableAnyOrigin]' to 'UnsafePointer[Int, 0, _default_alignment[::AnyType](), MutableAnyOrigin]'
it now complains more helpfully that:
... cannot be converted from 'UnsafePointer[UInt]' to 'UnsafePointer[Int]'
Tooling now prints the origins of ref arguments and results correctly, and
prints self instead of self: Self in methods.
The Mojo Language Server and generated documentation now print parametric
result types correctly, e.g. showing SIMD[type, simd_width] instead of
SIMD[$0, $1].
Generated API documentation now shows the signatures for structs, and
identifies @register_passable and @register_passable("trivial") types.
The VS Code extension now allows cancelling the installation of its private MAX SDK.
The VS Code extension now opens the Run and Debug tab automatically whenever a debug session starts.
The mojo debug --vscode command now support the --init-command and
--stop-on-entry flags. Execute mojo debug --help for more information.
The Mojo LLDB debugger on VS Code now supports inspecting the raw attributes
of variables that are handled as synthetic types, e.g. List from Mojo or
std::vector from C++.
The VS Code extension now allows selecting a default SDK when multiple are available.
UnsafePointer.bitcast() overload for DType has been removed. Wrap your
DType in a Scalar[my_dtype] to call the only overload of bitcast() now.Lifetime tracking is now fully field sensitive, which makes the uninitialized variable checker more precise.
Issue #1310 - Mojo permits the use of any constructor for implicit conversions
Issue #1632 - Mojo produces weird error when inout function is used in non mutating function
Issue #3444 - Raising init causing use of uninitialized variable
Issue #3544 - Known
mutable ref argument are not optimized as noalias by LLVM.
Issue #3559 - VariadicPack doesn't extend the lifetimes of the values it references.
Issue #3627 - Compiler
overlooked exclusivity violation caused by ref [MutableAnyOrigin] T
Issue #3710 - Mojo frees memory while reference to it is still in use.
Issue #3805 - Crash When Initializing !llvm.ptr.
Issue #3816 - Ternary if-operator doesn't propagate origin information.
Issue #3815 - [BUG] Mutability not preserved when taking the union of two origins.
Issue #3829 - Poor error message when invoking a function pointer upon an argument of the wrong origin
Issue #3830 - Failures emitting register RValues to ref arguments.
The VS Code extension now auto-updates its private copy of the MAX SDK.
The variadic initializer for SIMD now works in parameter expressions.
The VS Code extension now downloads its private copy of the MAX SDK in a way
that prevents ETXTBSY errors on Linux.
The VS Code extension now allows invoking a mojo formatter from SDK installations that contain white spaces in their path.
Special thanks to our community contributors: @soraos, @jjvraw, @bgreni, @thatstoasty, @szbergeron, @rd4com, @fknfilewalker, @gabrieldemarmiesse, @avitkauskas, and @martinvuyk.
]]>Here's a brief summary of some of the major changes in this release, with more detailed information in the following sections:
Mojo now supports Python 3.12 interoperability.
The set of automatically imported entities (types, aliases, functions) into users' Mojo programs has been dramatically reduced. This can break existing user code as users will need to explicitly import what they're using for cases previously automatically included before.
print() now requires that its arguments
conform to the Formattable trait.
This enables efficient stream-based writing by default, avoiding unnecessary
intermediate String heap allocations.
The new builtin input() function prints an
optional prompt and reads a line from standard input, in the same way as
Python.
Mojo now allows implicit definitions of variables within a fn in the same
way that has been allowed in a def. The var keyword is still allowed, but
is now optional.
Mojo now diagnoses "argument exclusivity" violations due to aliasing
references. Mojo requires references (including implicit references due to
borrowed/inout arguments) to be uniquely referenced (non-aliased) if
mutable. This is a warning in the 24.5 release, but will be upgraded to an
error in subsequent releases.
Mojo now supports "conditional conformances" where some methods on a struct have additional trait requirements that the struct itself doesn't.
DTypePointer, LegacyPointer, and Pointer have been removed. Use
UnsafePointer instead.
Functions that previously took a DTypePointer now take an equivalent
UnsafePointer. For more information on using pointers, see Unsafe
pointers in the Mojo Manual.
There are many new standard library APIs, with new features for strings, collections, and interacting with the filesystem and environment. Changes are listed in the standard library section.
The VS Code extension now supports a vendored MAX SDK for VS Code, which is automatically downloaded by the extension and it's used for all Mojo features, including the Mojo Language Server, the Mojo debugger, the Mojo formatter, and more.
mojo test now uses the Mojo compiler for running unit
tests. This will resolve compilation issues that sometimes appeared, and will
also improve overall test execution times.
Mojo now allows implicit definitions of variables within a fn in the same
way that has been allowed in a def. The var keyword is still allowed and
still denotes the declaration of a new variable with a scope (in both def
and fn). Relaxing this makes fn and def more similar, but they still
differ in other important ways.
Mojo now diagnoses "argument exclusivity" violations due to aliasing
references. Mojo requires references (including implicit references due to
borrowed/inout arguments) to be uniquely referenced (non-aliased) if
mutable. This is important for code safety, because it allows the compiler
(and readers of code) to understand where and when a value is mutated. It is
also useful for performance optimization because it allows the compiler to
know that accesses through immutable references cannot change behind the
scenes. Here is an invalid example:
fn take_two_strings(a: String, inout b: String):
# Mojo knows 'a' and 'b' cannot be the same string.
b += a
fn invalid_access():
var my_string = String()
# warning: passing `my_string` inout is invalid since it is also passed
# borrowed.
take_two_strings(my_string, my_string)
This is similar to Swift exclusivity checking and the Rust language sometimes known as "aliasing xor mutability". That said, the Mojo implementation details are somewhat different because lifetimes are embedded in types.
This is a warning in the 24.5 release, but will be upgraded to an error in subsequent releases.
Mojo now supports "conditional conformances" where some methods on a struct
have additional trait requirements that the struct itself doesn't. This is
expressed through an explicitly declared self type:
struct GenericThing[Type: AnyType]: # Works with anything
# Sugar for 'fn normal_method[Type: AnyType](self: GenericThing[Type]):'
fn normal_method(self): ...
# Just redeclare the requirements with more specific types:
fn needs_move[Type: Movable](self: GenericThing[Type], owned val: Type):
var tmp = val^ # Ok to move 'val' since it is Movable
...
fn usage_example():
var a = GenericThing[Int]()
a.normal_method() # Ok, Int conforms to AnyType
a.needs_move(42) # Ok, Int is movable
var b = GenericThing[NonMovable]()
b.normal_method() # Ok, NonMovable conforms to AnyType
# error: argument type 'NonMovable' does not conform to trait 'Movable'
b.needs_move(NonMovable())
Conditional conformance works with dunder methods and other things as well.
As a specific form of "conditional conformances", initializers in a struct
may indicate specific parameter bindings to use in the type of their self
argument. For example:
@value
struct MyStruct[size: Int]:
fn __init__(inout self: MyStruct[0]): pass
fn __init__(inout self: MyStruct[1], a: Int): pass
fn __init__(inout self: MyStruct[2], a: Int, b: Int): pass
def test(x: Int):
a = MyStruct() # Infers size=0 from 'self' type.
b = MyStruct(x) # Infers size=1 from 'self' type.
c = MyStruct(x, x) # Infers size=2 from 'self' type.
Mojo now supports named result bindings. Named result bindings are useful for
directly emplacing function results into the output slot of a function. This
feature provides more flexibility and guarantees around emplacing the result
of a function compared to "guaranteed" named return value optimization (NRVO).
If a @register_passable result is bound to a name, the result value is made
accessible as a mutable reference.
fn efficiently_return_string(b: Bool) -> String as output:
if b:
output = "emplaced!"
mutate(output)
return
return "regular return"
If we used a temporary for output instead, we would need to move into the
result slot, which wouldn't work if the result type was non-movable.
In a function with a named result, return may be used with no operand to
signal an exit from the function, or it can be used normally to specify the
return value of the function. The compiler will error if the result is not
initialized on all normal exit paths from the function.
__setitem__() now works with variadic argument lists such as:
struct YourType:
fn __setitem__(inout self, *indices: Int, val: Int): ...
The Mojo compiler now always passes the "new value" being set using the last
keyword argument of the __setitem__(), e.g. turning yourType[1, 2] = 3
into yourType.__setitem__(1, 2, val=3). This fixes Issue
#248.
Mojo context managers used in regions of code that may raise no longer need to
define a "conditional" exit function in the form of
fn __exit__(self, e: Error) -> Bool. This function allows the context
manager to conditionally intercept and handle the error and allow the function
to continue executing. This is useful for some applications, but in many cases
the conditional exit would delegate to the unconditional exit function
fn __exit__(self).
Concretely, this enables defining with regions that unconditionally
propagate inner errors, allowing code like:
def might_raise() -> Int:
...
def foo() -> Int:
with ContextMgr():
return might_raise()
# no longer complains about missing return
def bar():
var x: Int
with ContextMgr():
x = might_raise()
print(x) # no longer complains about 'x' being uninitialized
async functions now support memory-only results (like String, List,
etc.) and raises. Accordingly, both
Coroutine and
RaisingCoroutine have
been changed to accept AnyType instead of __TypeOfAllTypes. This means
the result types of async functions do not need to be Movable.
async fn raise_or_string(c: Bool) raises -> String:
if c:
raise "whoops!"
return "hello world!"
Note that async functions do not yet support indirect calls, ref results,
and constructors.
The Reference type (and many
iterators) now use infer-only
parameters to represent the
mutability of their lifetime, simplifying the interface.
The environment variable MOJO_PYTHON can be pointed to an executable to pin
Mojo to a specific version:
export MOJO_PYTHON="/usr/bin/python3.11"
Or a virtual environment to always have access to those Python modules:
export MOJO_PYTHON="~/venv/bin/python"
MOJO_PYTHON_LIBRARY still exists for environments with a dynamic libpython
but no Python executable.
The pointer aliasing semantics of Mojo have changed. Initially, Mojo adopted a C-like set of semantics around pointer aliasing and derivation. However, the C semantics bring a lot of history and baggage that are not needed in Mojo and which complicate compiler optimizations. The language overall provides a stronger set of invariants around pointer aliasing with lifetimes and exclusive mutable references to values, etc.
It is now forbidden to convert a non-pointer-typed value derived from a
Mojo-allocated pointer, such as an integer address, to a pointer-typed value.
"Derived" means there is overlap in the bits of the non-pointer-typed value
with the original pointer value. Accordingly, the
UnsafePointer
constructor that took an address keyword argument has been removed.
It is still possible to make this conversion in certain cases where it is absolutely necessary, such as interoperating with other languages like Python. In this case, the compiler makes two assumptions: any pointer derived from a non-pointer-typed value does not alias any Mojo-derived pointer and that any external function calls have arbitrary memory effects.
await on a coroutine now consumes it. This strengthens the invariant that
coroutines can be awaited only once.
builtin package:
The set of automatically imported entities (types, aliases, functions) into
users' Mojo programs has been dramatically reduced. Before, with the way the
builtin module was handled, all of the entities in the following modules
would be automatically included:
memory, sys, os, utils, python, bit, random, math,
builtin, collections
Now, only the explicitly enumerated entities in prelude/__init__.mojo are
the ones automatically imported into users' Mojo programs. This will break a
lot of user code as users will need to explicitly import what they're using
for cases previously commonly included before (such as
Optional,
Variant, and functions such as
abort(),
alignof(),
bitcast(),
bitwidthof(),
external_call(),
simdwidthof(), and
sizeof()).
Some types from the builtin module have been moved to different modules
for clarity which is made possible now that we have a prelude module that
can re-export symbols from modules other than builtin.
In particular, the builtin.string module has been moved to
collections.string.
Input and output:
Added the builtin input() function, which
behaves the same as Python.
(PR #3392)
name = input("Enter your name: ")
print("Hello, " + name + "!")
If the user enters "Mojo" it returns "Hello, Mojo!"
There is a known issue when running the input() function with JIT
compilation (see issue
#3479).
print() now requires that its arguments conform
to the Formattable trait. This enables
efficient stream-based writing by default, avoiding unnecessary intermediate
String heap allocations.
Previously, print() required types conform to Stringable. This meant
that to execute a call like print(a, b, c), at least three separate String
heap allocations were down, to hold the formatted values of a, b, and
c respectively. The total number of allocations could be much higher if,
for example, a.__str__() was implemented to concatenate together the
fields of a, like in the following example:
struct Point(Stringable):
var x: Float64
var y: Float64
fn __str__(self) -> String:
# Performs 3 allocations: 1 each for str(..) of each of the fields,
# and then the final returned `String` allocation.
return "(" + str(self.x) + ", " + str(self.y) + ")"
A type like the one above can transition to additionally implementing
Formattable with the following changes:
struct Point(Stringable, Formattable):
var x: Float64
var y: Float64
fn __str__(self) -> String:
return String.format_sequence(self)
fn format_to(self, inout writer: Formatter):
writer.write("(", self.x, ", ", self.y, ")")
In the example above,
String.format_sequence()
is used to construct a String from a type that implements Formattable.
This pattern of implementing a type's Stringable implementation in terms
of its Formattable implementation minimizes boilerplate and duplicated
code, while retaining backwards compatibility with the requirements of the
commonly used str() function.
debug_assert() now also
requires that its message argument conform to Formattable.
Added
TemporaryDirectory in
module tempfile.
(PR 2743)
Added
NamedTemporaryFile in
module tempfile.
(PR 2762)
String and friends:
The builtin.string module has been moved to
collections.string.
Added the
String.format()
method. (PR #2771)
Supports automatic and manual indexing of *args.
Examples:
print(
String("{1} Welcome to {0} {1}").format("mojo", "🔥")
)
# 🔥 Wecome to mojo 🔥
print(String("{} {} {}").format(True, 1.125, 2))
#True 1.125 2
String.format()
now supports conversion flags !s and !r, allowing for str() and
repr() conversions within format strings. (PR
#3279)
Example:
String("{} {!r}").format("Mojo", "Mojo")
# "Mojo 'Mojo'"
String("{0!s} {0!r}").format("Mojo")
# "Mojo 'Mojo'"
The String class now has
rjust(),
ljust(), and
center() methods
to return a justified string based on width and fillchar. (PR
#3278)
The atol() function now
correctly supports leading underscores, (e.g.atol("0x_ff", 0)), when the
appropriate base is specified or inferred (base 0). non-base-10 integer
literals as per Python's
Integer Literals.
(PR #3180)
Added the
unsafe_cstr_ptr()
method to String and StringLiteral, which returns an
UnsafePointer[c_char] for convenient interoperability with C APIs.
Added the byte_length() method to
String,
StringSlice,
and
StringLiteral
and deprecated their private _byte_length() methods. Added a warning to
the String.__len__()
method that it will return the length in Unicode codepoints in the future
and
StringSlice.__len__()
now does return the Unicode codepoints length.
(PR #2960)
Added a new
StaticString type
alias. This can be used in place of
StringLiteral for
runtime string arguments.
Added a
StringSlice
initializer that accepts a StringLiteral.
The StringRef constructors from DTypePointer.int8 have been changed to
take a UnsafePointer[c_char], reflecting their use for compatibility with
C APIs.
Continued the transition to UnsafePointer and unsigned byte type for
strings:
String.unsafe_ptr()
now returns an UnsafePointer[UInt8] (was UnsafePointer[Int8])
StringLiteral.unsafe_ptr()
now returns an UnsafePointer[UInt8] (was UnsafePointer[Int8])
UnsafePointer and other
reference type changes:
DTypePointer, LegacyPointer, and Pointer have been removed. Use
UnsafePointer instead.
For more information on using pointers, see Unsafe
pointers in the Mojo Manual.
Functions that previously took a DTypePointer now take an equivalent
UnsafePointer. A quick rule for conversion from DTypePointer to
UnsafePointer is:
DTypePointer[type] -> UnsafePointer[Scalar[type]]
There could be places that you have code of the form:
fn f(ptr: DTypePointer):
which is equivalent to DTypePointer[*_]. In this case you would have to
add an infer-only type parameter to the function:
fn f[type: DType, //](ptr: UnsafePointer[Scalar[type]]):
because we can’t have an unbound parameter inside the struct.
There could also be places where you use
DTypePointer[Scalar[DType.invalid/index]], and it would be natural to
change these to UnsafePointer[NoneType/Int]. But since these are not an
UnsafePointer that stores a Scalar, you might have to rebind/bitcast
to appropriate types.
The DTypePointer
load() and
store() methods
have been moved to UnsafePointer.
UnsafePointer now supports
strided_load(),
strided_store(),
gather(), and
scatter() when
the underlying type is Scalar[DType].
The global functions for working with UnsafePointer have transitioned to
being methods through the use of conditional conformances:
destroy_pointee(p) =>
p.destroy_pointee()move_from_pointee(p) =>
p.take_pointee()initialize_pointee_move(p, value) =>
p.init_pointee_move(value)initialize_pointee_copy(p, value) =>
p.init_pointee_copy(value)move_pointee(src=p1, dst=p2) =>
p.move_pointee_into(p2)The UnsafePointer.offset() method is deprecated and will be removed in a
future release. Use pointer
arithmetic instead.
new_ptr = ptr.offset(1)
Becomes:
new_ptr = ptr + 1
UnsafePointer now has an
alignment
parameter to specify the static alignment of the pointer. Consequently,
UnsafePointer.alloc()
no longer takes in an alignment parameter, and the alignment should be
specified in the type.
UnsafePointer[type].alloc[alignment](x) # now becomes
UnsafePointer[type, alignment].alloc(x)
UnsafePointer has a new exclusive: Bool = False
parameter. Setting this parameter to true tells the compiler that the user
knows this pointer and all those derived from it have exclusive access to
the underlying memory allocation. The compiler is not guaranteed to do
anything with this information.
It is no longer possible to cast (implicitly or explicitly) from Reference
to UnsafePointer. Instead of UnsafePointer(someRef) please use the
UnsafePointer.address_of(someRef[])
which makes the code explicit that the UnsafePointer gets the address of
what the reference points to.
Python interoperability changes:
Mojo now supports Python 3.12 interoperability.
Creating a nested
PythonObject from a list
or tuple of Python objects is possible now:
var np = Python.import_module("numpy")
var a = np.array([1, 2, 3])
var b = np.array([4, 5, 6])
var arrays = PythonObject([a, b])
assert_equal(len(arrays), 2)
Also allowing more convenient call syntax:
var stacked = np.hstack((a, b))
assert_equal(str(stacked), "[1 2 3 4 5 6]")
(PR #3264)
Accessing local Python modules with
Python.add_to_path(".")
is no longer required. It now behaves the same as Python. You can access
modules in the same folder as the target file:
mojo run /tmp/main.mojo can access /tmp/mymodule.py
mojo build main.mojo -o ~/myexe && ~/myexe can access ~/mymodule.py
Collections:
List values are now equality
comparable with == and != when their element type is equality
comparable. (PR #3195)
Optional values are now
equality comparable with == and != when their element type is equality
comparable.
Added a new Counter
dictionary-like type, matching most of the features of the Python one.
(PR #2910)
Dict now implements
setdefault(), which gets
a value from the dictionary by key, or sets it to a default if it doesn't
exist.
(PR #2803)
Dict now supports
popitem(), which removes and
returns the last item in the Dict.
(PR #2701)
Added a Dict.__init__()
overload to specify initial capacity.
(PR #3171)
The capacity has to be a power of two and greater than or equal to 8.
It allows for faster initialization by skipping incremental growth steps.
Example:
var dictionary = Dict[Int,Int](power_of_two_initial_capacity = 1024)
# Insert (2/3 of 1024) entries
ListLiteral now supports __contains__().
(PR #3251)
Filesystem and environment utilities:
Path.home() has been added to
return a path of the user's home directory.
os.path.expanduser() and
pathlib.Path.exapanduser()
have been added to allow expanding a prefixed ~ in a String or Path
with the user's home path:
import os
print(os.path.expanduser("~/.modular"))
# /Users/username/.modular
print(os.path.expanduser("~root/folder"))
# /var/root/folder (on macos)
# /root/folder (on linux)
os.path.split() has been added for
splitting a path into head, tail:
import os
head, tail = os.path.split("/this/is/head/tail")
print("head:", head)
print("tail:", tail)
# head: /this/is/head
# tail: tail
os.makedirs() and
os.removedirs() have been added for
creating and removing nested directories:
import os
path = os.path.join("dir1", "dir2", "dir3")
os.path.makedirs(path, exist_ok=True)
os.path.removedirs(path)
The pwd module has been added for accessing user
information in /etc/passwd on POSIX systems. This follows the same logic
as Python:
import pwd
import os
current_user = pwd.getpwuid(os.getuid())
print(current_user)
# pwd.struct_passwd(pw_name='jack', pw_passwd='********', pw_uid=501,
# pw_gid=20, pw_gecos='Jack Clayton', pw_dir='/Users/jack',
# pw_shell='/bin/zsh')
print(current_user.pw_uid)
# 501
root = pwd.getpwnam("root")
print(root)
# pwd.struct_passwd(pw_name='root', pw_passwd='*', pw_uid=0, pw_gid=0,
# pw_gecos='System Administrator', pw_dir='/var/root', pw_shell='/bin/zsh')
Other new traits and related features:
Added the
ExplicitlyCopyable trait
to mark types that can be copied explicitly, but which might not be
implicitly copyable.
This supports work to transition the standard library collection types away from implicit copyability, which can lead to unintended expensive copies.
Added the Identifiable
trait, used to describe types that implement the __is__() and
__isnot__() trait methods.
(PR #2807)
Types conforming to Boolable (that
is, those implementing __bool__()) no longer implicitly convert to Bool.
A new ImplicitlyBoolable
trait is introduced for types where this behavior is desired.
Miscellaneous:
NoneType is now a normal standard
library type, and not an alias for a raw MLIR type.
Function signatures written as fn() -> NoneType should transition to
being written as fn() -> None.
Mojo now has a UInt type for modeling
unsigned (scalar) integers with a platform-dependent width. UInt
implements most arithmetic operations that make sense for integers, with the
notable exception of __neg__(). Builtin functions such as min()/max(),
as well as math functions like ceildiv(), align_down(), and
align_up() are also implemented for UInt.
Now that we have a UInt type, use this to represent the return type of a
hash. In general, hashes should be an unsigned integer, and can also lead to
improved performance in certain cases.
Added the c_char type alias in sys.ffi.
sort() now supports a stable
parameter. It can be called by
sort[cmp_fn, stable=True](list)
The algorithm requires $$O(N)$$ auxiliary memory. If extra memory allocation fails, the program crashes.
sort() no longer takes LegacyPointer since that type is now removed.
Added the oct() builtin function
for formatting an integer in octal.
(PR #2914)
Added the assert_is() and
assert_is_not() test
functions to the testing module.
The math package now includes the pi,
e, and tau constants (Closes Issue
#2135).
The ulp function from numerics has been
moved to the math module.
bit module now supports
bit_reverse(),
byte_swap(), and
pop_count() for the Int type.
(PR #3150)
A few bit functions have been renamed for clarity:
countl_zero() ->
count_leading_zeros()
countr_zero() ->
count_trailing_zeros()
Slice now uses
OptionalReg[Int] for start and end and implements a constructor which
accepts optional values. Slice._has_end() has also been removed since a
Slice with no end is now represented by an empty Slice.end option.
(PR #2495)
var s = Slice(1, None, 2)
print(s.start.value()) # must retrieve the value from the optional
The rank argument for
algorithm.elementwise()
is no longer required and is only inferred.
The time.now() function has been deprecated. Please use
time.perf_counter() or
time.perf_counter_ns instead.
SIMD construction from Bool has been
restricted to DType.bool data type.
mojo test new features and changes:
mojo test now uses the Mojo compiler for running unit tests. This will
resolve compilation issues that sometimes appeared, and will also improve
overall test times, since we will only compile unit tests once before
executing all of them.
These changes do not apply to doctests, due to their different semantics.
The mojo test command now accepts a --filter option that will narrow the
set of tests collected and executed. The filter string is a POSIX extended
regular expression.
The mojo test command now supports using the same compilation options as
mojo build.
You can now debug unit tests using mojo test by passing the --debug
flag. Most debug flags are supported; run mojo test --help for a full
listing.
Debugging doctests is not currently supported.
Mojo debugger new features and changes:
The mojo debug --rpc command has been renamed to mojo debug --vscode, which is now able to
manage multiple VS Code windows.
The Mojo debugger now supports a break-on-raise command that indicated the
debugger to stop at any raise statements. A similar features has been
added to the debugger on VS Code.
The Mojo debugger now hides the artificial function arguments __result__
and __error__ created by the compiler for Mojo code.
VS Code support changes:
The VS Code extension now supports a vendored MAX SDK for VS Code, which is automatically downloaded by the extension and it's used for all Mojo features, including the Mojo Language Server, the Mojo debugger, the Mojo formatter, and more.
A proxy has been added to the Mojo Language Server on VS Code that handles crashes more gracefully.
The Mojo Language Server no longer sets . as a commit character for
auto-completion.
Support for the legacy fn __init__(...) -> Self: form has been removed from
the compiler, please switch to using fn __init__(inout self, ...): instead.
The builtin tensor module has been removed. Identical functionality is
available in max.tensor, but it is generally
recommended to use structs from the buffer
module when possible instead.
Removed String.unsafe_uint8_ptr(). String.unsafe_ptr() now returns the
same thing.
Removed StringLiteral.unsafe_uint8_ptr() and StringLiteral.as_uint8_ptr().
Removed SIMD.splat(value: Scalar[type]). Use the constructor for SIMD
instead.
Removed the SIMD.{add,mul,sub}_with_overflow() methods.
Removed the SIMD.min() and SIMD.max() methods. Identical functionality is
available using the builtin min() and
max() functions.
Removed the Mojo Language Server warnings for unused function arguments.
Run Mojo File in Dedicated Terminal action has been removed, and the
action Run Mojo File will always open a dedicated terminal for each mojo
file to guarantee a correct environment.
Fixed a crash in the Mojo Language Server when importing the current file.
Fixed crash when specifying variadic keyword arguments without a type
expression in def functions, e.g.:
def foo(**kwargs): ... # now works
Mojo now prints ref arguments and results in generated documentation
correctly.
#1734 - Calling
__copyinit__ on self causes crash.
#3142 - [QoI] Confusing
__setitem__ method is failing with a "must be mutable" error.
#248 - [Feature] Enable
__setitem__ to take variadic arguments
#3065 - Fix incorrect
behavior of SIMD.__int__ on unsigned types
#3045 - Disable implicit
SIMD conversion routes through Bool
#3126 - [BUG] List doesn't work at compile time.
#3237 - [BUG] Difference
between __getitem__ and [.] operator.
#3336 - Fix outdated
references to let in REPL documentation.
The VS Code extension no longer caches the information of the selected MAX SDK, which was causing issues upon changes in the SDK.
The Mojo debugger now stops showing spurious warnings when parsing closures.
Special thanks to our community contributors: @jjvraw, @artemiogr97, @martinvuyk, @jayzhan211, @bgreni, @mzaks, @msaelices, @rd4com, @jiex-liu, @kszucs, @thatstoasty
]]>Big themes for this release:
Improvements to the performance and ease-of-use for def functions.
Continued unification of standard library APIs around the UnsafePointer
type.
Many quality-of-life improvements for the standard library collection types.
Significant performance improvements when inserting into a Dict. Performance
on this metric is still not where we'd like it to be, but it is much improved.
A new @parameter for mechanism for expressing compile-time loops, which
replaces the earlier (and less reliable) @unroll decorator.
New Mojo Manual pages on Control flow, Testing and using unsafe pointers.
Mojo has changed how def function arguments are processed. Previously, by
default, arguments to a def were treated according to the owned
convention, which makes a copy of the value, enabling that value to be mutable
in the callee.
This could lead to major performance issues because of the proliferation of
unnecessary copies. It also required you to declare non-copyable types as
borrowed explicitly. Now Mojo takes a different approach: def functions
take arguments as borrowed by default (consistent with fn functions) but
will make a local copy of the value only if the argument is mutated in the
body of the function.
This improves consistency, performance, and ease of use.
Implicit variable definitions in a def function are more flexible: you can
now implicitly declare variables as the result of a tuple return, using
a,b,c = foo(). For example:
def return_two(i: Int) -> (Int, Int):
return i, i+1
a, b = return_two(5)
Implicit variable declarations can also now shadow global immutable symbols (such as module names and built-ins) without getting a compiler error. For example:
slice = foo()
Mojo functions can return an auto-dereferenced reference to storage with a
new ref keyword in the result type specifier. For example:
@value
struct Pair:
var first: Int
var second: Int
fn get_first_ref(inout self) -> ref [self] Int:
return self.first
fn show_mutation():
var somePair = Pair(5, 6)
somePair.get_first_ref() = 1
This approach provides a general way to return an "automatically dereferenced"
reference of a given type. Notably, this eliminates the need for
__refitem__() to exist. __refitem__() has thus been removed and replaced
with __getitem__() that returns a reference.
Mojo added support for infer-only parameters. Infer-only parameters must
appear at the beginning of the parameter list and cannot be explicitly
specified by the user. They are declared to the left of a // marker, much
like positional-only parameters. This allows programmers to define functions
with dependent parameters to be called without the caller specifying all the
necessary parameters. For example:
fn parameter_simd[dt: DType, //, value: Scalar[dt]]():
print(value)
fn call_it():
parameter_simd[Int32(42)]()
In the above example, Int32(42) is passed directly into value, the first
parameter that isn't infer-only. dt is inferred from the parameter itself
to be DType.int32.
This also works with structs. For example:
struct ScalarContainer[dt: DType, //, value: Scalar[dt]]:
pass
fn foo(x: ScalarContainer[Int32(0)]): # 'dt' is inferred as `DType.int32`
pass
This should make working with dependent parameters more ergonomic. See Infer-only parameters in the Mojo Manual.
Mojo now allows functions overloaded on parameters to be resolved when forming references to, but not calling, those functions. For example, the following now works:
fn overloaded_parameters[value: Int32]():
pass
fn overloaded_parameters[value: Float32]():
pass
fn form_reference():
alias ref = overloaded_parameters[Int32()] # works!
Mojo now supports adding a @deprecated decorator on structs, functions,
traits, aliases, and global variables. The decorator marks the attached
declaration as deprecated and causes a warning to be emitted when the
deprecated declaration is referenced in user code. The decorator requires a
deprecation message, specified as a string literal.
@deprecated("Foo is deprecated, use Bar instead")
struct Foo:
pass
fn outdated_api(x: Foo): # warning: Foo is deprecated, use Bar instead
pass
@deprecated("use another function!")
fn bar():
pass
fn techdebt():
bar() # warning: use another function!
Mojo has introduced
@parameter for,
a new feature for compile-time programming. @parameter for defines a for
loop where the sequence and the induction values in the sequence must be
parameter values. For example:
fn parameter_for[max: Int]():
@parameter
for i in range(max)
@parameter
if i == 10:
print("found 10!")
Currently, @parameter for requires the sequence's __iter__() method to
return a _StridedRangeIterator, meaning the induction variables must be
Int. The intention is to lift these restrictions in the future.
The is_mutable parameter of Reference and AnyLifetime is now a Bool,
not a low-level __mlir_type.i1 value.
This improves the ergonomics of spelling out a
Reference type explicitly.
Mojo will now link to a Python dynamic library based on the Python on top of
your search path: PATH. This enables you to activate a virtual environment
like conda and have access to Python modules installed in that environment
without setting MOJO_PYTHON_LIBRARY. Previously Mojo would find a
libpython dynamic library on installation and put the path in
.modular/modular.cfg, which could result in version conflicts if you
activated a virtual environment of a different Python version.
AnyRegType has been renamed to __TypeOfAllTypes and Mojo now forbids
binding non-trivial register-passable types to __TypeOfAllTypes. This
closes a major safety hole in the language. Please use AnyType for generic
code going forward.
The let keyword has been completely removed from the language. We previously
removed let declarations but still provided an error message to users. Now,
it is completely gone from the grammar.
New traits and related features:
Added built-in repr() function and
Representable trait.
(PR #2361)
Added the Indexer trait to denote
types that implement the __index__() method which allows these types to be
accepted in common __getitem__() and __setitem__() implementations, as
well as allow a new built-in
index()
function to be called on them. Most standard library containers can now be
indexed by any type that implements Indexer. For example:
@value
struct AlwaysZero(Indexer):
fn __index__(self) -> Int:
return 0
struct MyList:
var data: List[Int]
fn __init__(inout self):
self.data = List[Int](1, 2, 3, 4)
fn __getitem__[T: Indexer](self, idx: T) -> Int:
return self.data[index(idx)]
print(MyList()[AlwaysZero()]) # prints `1`
Types conforming to the Indexer trait are implicitly convertible to Int.
This means you can write generic APIs that take Int instead of making them
take a generic type that conforms to Indexer. For example:
@value
struct AlwaysZero(Indexer):
fn __index__(self) -> Int:
return 0
@value
struct Incrementer:
fn __getitem__(self, idx: Int) -> Int:
return idx + 1
var a = Incrementer()
print(a[AlwaysZero()]) # works and prints 1
(PR #2685)
Added traits allowing user-defined types to be supported by various built-in and math functions.
| Function | Trait | Required method |
|---|---|---|
abs() | Absable | __abs__() |
pow() | Powable | __pow__() |
round() | Roundable | __round__() |
math.ceil | math.Ceilable | __ceil__() |
math.ceildiv | math.CeilDivable math.CeilDivableRaising | __ceildiv__() |
math.floor | math.Floorable | __floor__() |
math.trunc | Truncable | __trunc__() |
Notes:
Conforming to the Powable trait also means that the type can be used
with the power operator (**).
For ceildiv(), structs can conform to either the CeilDivable trait
or CeilDivableRaising trait.
Due to ongoing refactoring, the traits Ceilable, CeilDivable,
Floorable, and Truncable do not appear in the API reference. They
should be imported from the math module, except for Truncable which
is (temporarily) available as a built-in trait and does not need to be
imported.
Example:
from math import sqrt
@value
struct Complex2(Absable, Roundable):
var re: Float64
var im: Float64
fn __abs__(self) -> Self:
return Self(sqrt(self.re * self.re + self.im * self.im), 0.0)
fn __round__(self) -> Self:
return Self(round(self.re, 0), round(self.im, 0))
fn __round__(self, ndigits: Int) -> Self:
return Self(round(self.re, ndigits), round(self.im, ndigits))
Benchmarking:
bencher module as part of the
benchmark package is now public and documented. This module provides
types such as Bencher which provides the ability to execute a Benchmark
and allows for benchmarking configuration via the BenchmarkConfig struct.String and friends:
Breaking. Implicit conversion to String is now removed for builtin
classes/types. Use str() explicitly to convert to String.
Added
String.isspace()
method conformant with Python's universal separators. This replaces the
isspace() free function from the string module. (If you need the old
function, it is temporarily available as _isspace(). It now takes a
UInt8 but is otherwise unchanged.)
String.split() now
defaults to whitespace and has Pythonic behavior in that it removes all
adjacent whitespace by default.
String.strip(),
lstrip() and
rstrip() can now
remove custom characters other than whitespace. In addition, there are now
several useful aliases for whitespace, ASCII lower/uppercase, and so on.
(PR #2555)
String now has a
splitlines()
method, which allows splitting strings at line boundaries. This method
supports universal
newlines
and provides an option to retain or remove the line break characters. (PR
#2810)
InlinedString has been renamed to
InlineString
to be consistent with other types.
StringRef now
implements
strip(),
which can be used to remove leading and trailing whitespace. (PR
#2683)
StringRef now implements
startswith()
and
endswith().
(PR #2710)
Added a new
StringSlice
type, to replace uses of the unsafe StringRef type in standard library
code.
StringSlice is a non-owning reference to encoded string data. Unlike
StringRef, a StringSlice is safely tied to the lifetime of the data it
points to.
as_string_slice()
methods to String and StringLiteral.StringSlice initializer from an UnsafePointer and a length in
bytes.Added a new
as_bytes_slice()
method to String and StringLiteral, which returns a Span of the bytes
owned by the string.
Continued transition to
UnsafePointer and
unsigned byte type for strings:
String._as_ptr() to
String.unsafe_ptr(),
and changed return type to UnsafePointer (was DTypePointer).StringLiteral.data() to
StringLiteral.unsafe_ptr(),
and changed return type to UnsafePointer (was DTypePointer).InlineString.as_ptr() has been renamed to
unsafe_ptr()
and now returns an UnsafePointer[UInt8] (was
DTypePointer[DType.int8]).StringRef.data is now an UnsafePointer (was DTypePointer) and
StringRef.unsafe_ptr()
now returns an UnsafePointer[UInt8] (was DTypePointer[DType.int8]).Other built-ins:
The Slice.__len__() function has been removed and
Slice no longer conforms
to the Sized trait. This clarifies the ambiguity of the semantics: the
length of a slice always depends on the length of the object being sliced.
Users that need the existing functionality can use the
Slice.unsafe_indices()
method. This makes it explicit that this implementation does not check if
the slice bounds are concrete or within any given object's length.
Added a built-in sort() function for
lists of elements that conform to the
ComparableCollectionElement
trait.(PR #2609)
int() can now take a string and a
specified base to parse an integer from a
string: int("ff", 16) returns 255. Additionally, if a base of zero is
specified, the string will be parsed as if it was an integer literal, with
the base determined by whether the string contains the prefix "0x",
"0o", or "0b".
(PR #2273,
fixes #2274)
Added the bin() built-in function
to convert integral types into their binary
string representation.
(PR #2603)
Added the atof() built-in
function, which can convert a String to a float64. (PR
#2649)
You can now use the built-in any() and
all() functions to check for truthy
elements in a collection. Because SIMD.__bool__() is now constrained to
size=1, You must explicitly use these to get the truthy value of a SIMD
vector with more than one element. This avoids common bugs around implicit
conversion of SIMD to Bool.
(PR #2600)
For example:
fn truthy_simd():
var vec = SIMD[DType.int32, 4](0, 1, 2, 3)
if any(vec):
print("any elements are truthy")
if all(vec):
print("all elements are truthy")
object now implements all the bitwise
operators.
(PR #2324)
Tuple now supports __contains__().
(PR #2709) For example:
var x = Tuple(1, 2, True)
if 1 in x:
print("x contains 1")
ListLiteral and Tuple
now only require that element types be Movable. Consequently,
ListLiteral and Tuple are themselves no longer Copyable.
Added new ImmutableStaticLifetime and MutableStaticLifetime helpers.
UnsafePointer and
others:
Added new memcpy() overload for
UnsafePointer[Scalar[_]] pointers.
Removed the get_null() method from UnsafePointer and other pointer
types. Please use the default constructor instead: UnsafePointer[T]().
Many functions returning a pointer type have been unified to have a public
API function of unsafe_ptr().
The Tensor.data() method has been renamed to unsafe_ptr(). The return
type is still a DTypePointer[T].
Collections:
List now has an
index() method that allows you
to find the (first) location of an element in a List of
EqualityComparable types. For example:
var my_list = List[Int](2, 3, 5, 7, 3)
print(my_list.index(3)) # prints 1
List can now be converted to a String with a simplified syntax:
var my_list = List[Int](2, 3)
print(my_list.__str__()) # prints [2, 3]
Note that List doesn't conform to the Stringable trait yet so you cannot
use str(my_list) yet.
(PR #2673)
List has a simplified syntax to call the
count() method:
my_list.count(x).
(PR #2675)
List() now supports __contains__(), so you can now use lists with the
in operator:
if x in my_list:
(PR #2667)
List now has an
unsafe_get() to get the
reference to an element without bounds check or wraparound for negative
indices. Note that this method is unsafe. Use with caution.
PR #2800
Added a fromkeys() method
to Dict to return a Dict with the specified keys and values.
(PR 2622)
Dict now supports reversed()
for its items() and values() iterators.
(PR #2340)
Dict now has a simplified conversion to String with my_dict.__str__().
Note that Dict does not conform to the Stringable trait so
str(my_dict) is not possible yet.
(PR #2674)
Dict now implements get(key)
and get(key, default) functions.
(PR #2519)
Added a temporary __get_ref(key) method to Dict, allowing you to get a
Reference to a dictionary value.
Added a new
InlineList type, a
stack-allocated list with a static maximum size. (PR
2587#)
(PR #2703)
Added a new Span type for taking slices
of contiguous collections. (PR
#2595)
os module:
The os module now provides functionality for adding and removing
directories using mkdir() and
rmdir().
(PR #2430)
Added the os.path.getsize() function,
which gives the size in bytes of the file identified by the path.
(PR 2626)
Added os.path.join() function.
(PR 2792)
Added a new tempfile module, with
gettempdir() and mkdtemp() functions.
(PR 2742)
SIMD type:
Added SIMD.shuffle() with
IndexList mask.
(PR #2315)
SIMD.__bool__() is constrained
such that it only works when size is 1. For SIMD vectors with more than
one element, use any() or
all().
(PR #2502)
The SIMD.reduce_or() and
SIMD.reduce_and() methods are
now bitwise operations, and support integer types.
(PR #2671)
Added SIMD.__repr__() to get
the verbose string representation of SIMD types.
(PR #2728)
math package:
The math.bit module has been moved to a new top-level
bit module. The following functions in this
module have been renamed:
ctlz -> countl_zerocttz -> countr_zerobit_length -> bit_widthctpop -> pop_countbswap -> byte_swapbitreverse -> bit_reverseThe math.rotate_bits_left() and math.rotate_bits_right() functions have
been moved to the bit module.
The is_power_of_2() function in the math module is now called
is_power_of_two() and located in the bit module.
The abs(), round(), min(), max(), pow(), and divmod() functions
have moved from math to builtin, so you no longer need to import these
functions.
The math.tgamma() function has been renamed to
math.gamma() to conform with Python's
naming.
The implementation of the following functions have been moved from the
math module to the new utils.numerics
module: isfinite(), isinf(), isnan(), nan(), nextafter(), and
ulp(). The functions continue to be exposed in the math module.
math.gcd() now works on negative inputs, and
like Python's implementation, accepts a variadic list of integers. New
overloads for a List or Spanof integers are also added.
(PR #2777)
Async and coroutines:
Coroutine now requires a
lifetime parameter. This parameter is set automatically by the parser when
calling an async function. It contains the lifetimes of all the arguments
and any lifetime accesses by the arguments. This ensures that argument
captures by async functions keep the arguments alive as long as the
coroutine is alive.
Async function calls are no longer allowed to borrow non-trivial register-passable types. Because async functions capture their arguments but register-passable types don't have lifetimes (yet), Mojo is not able to correctly track the reference, making this unsafe. To cover this safety gap, Mojo has temporarily disallowed binding non-trivial register-passable types to borrowed arguments in async functions.
Miscellaneous:
Added an InlineArray
type that works on memory-only types. Compare with the existing
StaticTuple type, which is
conceptually an array type, but only works on __TypeOfAllTypes. (PR
#2294)
The base64 package now includes encoding and
decoding support for both the Base64 and Base16 encoding schemes.
(PR #2364)
(PR #2584)
The take() function in Variant and
Optional has been renamed to
unsafe_take().
The get() function in Variant has been replaced by __getitem__(). That
is, v.get[T]() should be replaced with v[T].
Various functions in the algorithm module are now built-in functions. This
includes sort(), swap(), and partition(). swap() and partition()
will likely shuffle around as we're reworking our built-in sort() function
and optimizing it.
infinity and NaN are now correctly handled in
testing.assert_almost_equal()
and an inf function has been added to utils/numerics.mojo.
(PR #2375)
Invoking mojo package my-package -o my-dir on the command line, where
my-package is a Mojo package source directory, and my-dir is an existing
directory, now outputs a Mojo package to my-dir/my-package.mojopkg.
Previously, this had to be spelled out, as in -o my-dir/my-package.mojopkg.
The Mojo Language Server now reports a warning when a local variable is unused.
Several mojo subcommands now support a --diagnostic-format option that
changes the format with which errors, warnings, and other diagnostics are
printed. By specifying --diagnostic-format json on the command line, errors
and other diagnostics will be output in a structured
JSON Lines format that is easier for machines to
parse.
The full list of subcommands that support --diagnostic-format is as follows:
mojo build, mojo doc, mojo run, mojo package, and mojo test.
Further, the mojo test --json option has been subsumed into this new option;
for the same behavior, run mojo test --diagnostic-format json.
Note that the format of the JSON output may change; we don't currently guarantee its stability across releases of Mojo.
A new --validate-doc-strings option has been added to mojo to emit errors
on invalid doc strings instead of warnings.
The --warn-missing-doc-strings flag for mojo has been renamed to
--diagnose-missing-doc-strings.
A new decorator, @doc_private, was added that can be used to hide a
declaration from being generated in the output of mojo doc. It also removes
the requirement that the declaration has documentation (for example, when used
with --diagnose-missing-doc-strings).
Debugger users can now set breakpoints on function calls in O0 builds even if the call has been inlined by the compiler.
The Mojo Language Server now supports renaming local variables.
The @unroll decorator has been deprecated and removed. The decorator was
supposed to guarantee that a decorated loop would be unrolled, or else the
compiler would error. In practice, this guarantee was eroded over time, as
a compiler-based approach cannot be as robust as the Mojo parameter system.
In addition, the @unroll decorator did not make the loop induction variables
parameter values, limiting its usefulness. Please see @parameter for for a
replacement!
The method object.print() has been removed. Since object now conforms to
the Stringable trait, you can use print(my_object) instead.
The following functions have been removed from the math module:
clamp(); use the new SIMD.clamp() method instead.round_half_down() and round_half_up(); these can be trivially
implemented using the ceil() and floor() functions.add(), sub(), mul(), div(), mod(), greater(), greater_equal(),
less(), less_equal(), equal(), not_equal(), logical_and(),
logical_xor(), and logical_not(); Instead, users should rely directly on
the corresponding operators (+, -, *, /, %, >, >=, <, <=,
==, !=, &, ^, and ~).identity() and reciprocal(); users can implement these trivially.select(); removed in favor of using SIMD.select() directly.is_even() and is_odd(); these can be trivially implemented using bitwise
& with 1.roundeven(); the new SIMD.roundeven() method now provides the identical
functionality.div_ceil(); use the new ceildiv() function.rotate_left() and rotate_right(); the same functionality is available in
the builtin SIMD.rotate_{left,right}() methods for SIMD types, and the
bit.rotate_bits_{left,right})() methods for Int.math.pow() taking an integer parameter exponent.align_down_residual(); it can be trivially implemented using
align_down().all_true(), any_true(), and none_true(); use SIMD.reduce_and() and
SIMD.reduce_or() directly.reduce_bit_count(); use the new SIMD.reduce_bit_count() directly.rint() and nearbyint(); use round() or SIMD.roundeven() as
appropriate.The EvaluationMethod has been removed from math.polynomial and Estrin's
method is no longer available. This method was limited to degree 10 or less,
underutilized, and its performance unclear. In the future, this might be
reintroduced with an improved implementation if needed, when better
performance benchmarking infrastructure is available. The default behavior of
math.polynomial.polynomial_evaluate() is unchanged (Horner's method).
The math.bit.select() and math.bit.bit_and() functions have been removed.
The same functionality is available in the builtin SIMD.select and
SIMD.__and__() methods, respectively.
The math.limit module has been removed. The same functionality is available
as follows:
math.limit.inf(): use utils.numerics.max_or_inf()math.limit.neginf(): use utils.numerics.min_or_neg_inf()math.limit.max_finite(): use utils.numerics.max_finite()math.limit.min_finite(): use utils.numerics.min_finite()The tensor.random module has been removed. The same functionality is now
accessible via the Tensor.rand() and Tensor.randn() static methods.
The builtin SIMD struct no longer conforms to Indexer; users must
explicitly cast Scalar values using int.
// on FloatLiteral in alias expression.assert_raises
to include calling location.Special thanks to our community contributors:
@rd4com, @toiletsandpaper, @helehex, @artemiogr97, @mikowals, @kernhanda, @lsh, @LJ-9801, @YichengDWu, @gabrieldemarmiesse, @fknfilewalker, @jayzhan211, @martinvuyk, @ChristopherLR, @mzaks, @bgreni, @Brian-M-J, @leandrolcampos
]]>AnyPointer was renamed to
UnsafePointer and is now
Mojo's preferred unsafe pointer type. It has several enhancements, including:
The element type can now be any type: it doesn't require Movable.
Because of this, the take_value(), emplace_value(), and move_into()
methods have been changed to top-level functions and renamed. The new
functions are:
A new
destroy_pointee()
function runs the destructor on the pointee.
UnsafePointer can be initialized directly from a Reference with
UnsafePointer(someRef) and can convert to a reference with
yourPointer[]. Both infer element type and address space. Note that when
you convert a pointer to a reference, there's no way for Mojo to track the
lifetime of the original value. So the resulting reference is no safer than
the original pointer.
All of the pointer types received some cleanup to make them more consistent,
for example the unsafe.bitcast() global function is now a consistent
bitcast() method
on the pointers, which can convert element type and address space.
Improvements to variadic arguments support.
Heterogeneous variadic pack arguments now work reliably even with memory
types, and have a more convenient API to use, as defined by the
VariadicPack type. For
example, a simplified version of print can be implemented like this:
fn print[T: Stringable, *Ts: Stringable](first: T, *rest: *Ts):
print_string(str(first))
@parameter
fn print_elt[T: Stringable](a: T):
print_string(" ")
print_string(a)
rest.each[print_elt]()
Mojo now supports declaring functions that have both optional and variadic arguments, both positional and keyword-only. For example, this now works:
fn variadic_arg_after_default(
a: Int, b: Int = 3, *args: Int, c: Int, d: Int = 1, **kwargs: Int
): ...
Positional variadic parameters also work in the presence of optional parameters. That is:
fn variadic_param_after_default[e: Int, f: Int = 2, *params: Int]():
pass
Note that variadic keyword parameters are not supported yet.
For more information, see Variadic arguments in the Mojo Manual.
The mojo build and mojo run commands now support a -g option. This
shorter alias is equivalent to writing --debug-level full. This option is
also available in the mojo debug command, but is already the default.
Many new standard library APIs have been filled in, including many community contributions. Changes are listed in the standard library section.
The Mojo Manual has a new page on Types.
Certain dunder methods that take indices (__getitem__(), __setitem__(),
and __refitem__()) or names (__getattr__() and __setattr__()) can now
take the index or name as a parameter value instead of an argument value. This
is enabled when you define one of these methods with no argument other than
self (for a getter) or self and the set value (for a setter).
This enables types that can only be subscripted into with parameters, as well as things like the following example, which passes the attribute name as a parameter so that attribute names can be checked at compile time.
struct RGB:
fn __getattr__[name: StringLiteral](self) -> Int:
@parameter
if name == "r": return ...
elif name == "g": return ...
else:
constrained[name == "b", "can only access with r, g, or b members"]()
return ...
var rgb = RGB()
print(rgb.b) # Works
print(rgb.q) # Compile error
Mojo now allows users to capture the source location of code and call location
of functions dynamically using the __source_location() and
__call_location() functions. For example:
from builtin._location import __call_location
@always_inline
fn my_assert(cond: Bool, msg: String):
if not cond:
var call_loc = __call_location()
print("In", call_loc.file_name, "on line", str(call_loc.line) + ":", msg)
fn main():
my_assert(False, "always fails") # some_file.mojo, line 193
This prints "In /path/to/some_file.mojo on line 193: always fails". Note
that __call_location() only works in @always_inline or
@always_inline("nodebug") functions. It gives incorrect results if placed in
an @always_inline function that's called from an
@always_inline("nodebug") function.
This feature is still evolving and for the time being you need to explicitly import these APIs, as shown above. In the future, these will probably be built-in functions and not require an import statement.
Neither __source_location() nor __call_location() work when called in a
parameter context. For example:
from builtin._location import __call_location
@always_inline
fn mystery_location() -> String:
var loc = __call_location()
return str(loc.file_name)
def main():
alias doesnt_work = mystery_location() # <unknown location in parameter context>
List has several new methods:
pop(index) for removing an element at a particular index.
By default, List.pop() removes the last element in the list.
(@LJ-9801, fixes
#2017)
resize(new_size) for resizing the list without the need to
specify an additional value.
(@mikowals, fixes
#2133)
insert(index, value) for inserting a value at a specified index
into the List. (@whym1here, fixes
#2134)
A new constructor List(ptr, size, capacity) to avoid needing to
do a deep copy of an existing contiguous memory allocation when constructing
a new List. (@StandinKP, fixes
#2170)
Dict now has a update() method to
update keys/values from another Dict.
(@gabrieldemarmiesse)
Set now has named methods for set
operations:
difference() mapping to -difference_update() mapping to -=intersection_update() mapping to &=update() mapping to |=Dict, List, and Set all conform to the Boolable trait. The collections
evaluate to True if they contain any elements, False otherwise:
def list_names(names: List[String]):
if names:
for name in names:
print(name[])
else:
print("No names to list.")
Added reversed() function for
creating reversed iterators. Several range types, List, and Dict now
support iterating in reverse.
var numbers = List(1, 2, 3, 4, 5)
for number in reversed(numbers):
print(number)
(@helehex and @jayzhan211, contributes towards #2325)
Optional now implements
__is__ and __isnot__ methods so that you can compare an Optional with
None. For example:
var opt = Optional(1)
if opt is not None:
print(opt.value()[])
Tuple now works with memory-only element
types like String and allows you to directly index into it with a parameter
expression. This means you can now simply use x = tup[1] like Python
instead of x = tup.get[1, Int](). You can also assign into tuple elements
now as well with tup[1] = x.
var tuple = ("Green", 9.3)
var name = tuple[0]
var value = tuple[1]
Note that because the subscript must be a parameter expression, you can't
iterate through a Tuple using an ordinary for loop.
The Reference type has several
changes, including:
It has moved to the memory.reference module instead of memory.unsafe.
Reference now has an
unsafe_bitcast()
method, similar to the pointer types.
Several unsafe methods were removed, including offset(),
destroy_element_unsafe() and emplace_ref_unsafe(). This is because
Reference is a safe type—use UnsafePointer to do unsafe operations.
Bool can now be implicitly converted from
any type conforming to the Boolable
trait. This means that you no longer need to write code like this:
@value
struct MyBoolable:
fn __bool__(self) -> Bool: ...
fn takes_boolable[T: Boolable](cond: T): ...
takes_boolable(MyBoolable())
Instead, you can simply write:
fn takes_bool(cond: Bool): ...
takes_bool(MyBoolable())
Note that calls to takes_bool() will perform the implicit conversion, so in
some cases is it still better to explicitly declare a type parameter, e.g.:
fn takes_two_boolables[T: Boolable](a: T, b: T):
# Short circuit means `b.__bool__()` might not be evaluated.
if a.__bool__() and b.__bool__():
...
PythonObject now conforms
to the KeyElement trait, meaning
that it can be used as key type for
Dict. This allows you to easily build
and interact with Python dictionaries in Mojo:
def main():
d = PythonObject(Dict[PythonObject, PythonObject]())
d["foo"] = 12
d[7] = "bar"
d["foo"] = [1, 2, "something else"]
print(d) # prints `{'foo': [1, 2, 'something else'], 7: 'bar'}`
FileHandle.seek() now has a
whence argument that defaults to os.SEEK_SET to seek from the beginning of
the file. You can now set to os.SEEK_CUR to offset by the current
FileHandle seek position:
var f = open("/tmp/example.txt")
# Skip 32 bytes
f.seek(os.SEEK_CUR, 32)
Or os.SEEK_END to offset from the end of file:
# Start from 32 bytes before the end of the file
f.seek(os.SEEK_END, -32)
FileHandle.read() can now
read straight into a
DTypePointer:
var file = open("/tmp/example.txt", "r")
# Allocate and load 8 elements
var ptr = DTypePointer[DType.float32].alloc(8)
var bytes = file.read(ptr, 8)
print("bytes read", bytes)
print(ptr.load[width=8]())
The sys module now contains an exit() function that would exit a Mojo
program with the specified error code.
from sys import exit
exit(0)
The constructors for Tensor have been changed to be more consistent. As a
result, constructors take the shape as the first argument (instead of the
second) when constructing a tensor with pointer data.
If you pass a single scalar value to the Tensor constructor, it now
broadcasts the value to all elements in the tensor. For example,
Tensor[DType.float32](TensorShape(2,2), 0) constructs a 2x2 tensor
initialized with all zeros. This provides an easy way to fill in the data of a
tensor.
String now has
removeprefix() and removesuffix() methods.
(@gabrieldemarmiesse)
The ord and
chr functions have been
improved to accept any Unicode character. (@mzaks,
contributes towards #1616)
atol() now handles
whitespace. The atol()function is used internally by String.__int__(), so
int(String( " 10 ")) now returns 10 instead of raising an error.
(@artemiogr97)
SIMD now implements the __rmod__()
method. (@bgreni, fixes
#1482)
bool(None) is now implemented.
(@zhoujingya)
The DTypePointer type
now implements gather() for gathering a SIMD vector from offsets of a
current pointer. Similarly, support for scatter() was added to scatter a
SIMD vector into offsets of the current pointer.
(@leandrolcampos)
The len() function now handles a
range() specified with a negative end
value, so that things like len(range(-1)) work correctly.
(@soraros)
debug_assert() now prints
its location (filename, line, and column where it was called) in its error
message. Similarly, the assert helpers in the
testing module now include location
information in their messages.
The
testing.assert_equal[SIMD]()
function now raises if any of the elements mismatch in the two SIMD
arguments being compared.
(@gabrieldemarmiesse)
The
testing.assert_almost_equal()
and math.isclose() functions now have an
equal_nan flag. When set to True, then NaNs are considered equal.
The object type now supports the
division, modulo, and left and right shift operators, including the in-place
and reverse variants.
(@LJ-9801, fixes
#2224)
Added checked arithmetic operations for SIMD integers.
SIMD integer types (including the sized integer scalars like Int64) can
now perform checked additions, subtractions, and multiplications using the
following new methods:
add_with_overflow()sub_with_overflow()mul_with_overflow()Checked arithmetic allows the caller to determine if an operation exceeded the numeric limits of the type. For example:
var simd = SIMD[DType.int8, 4](7, 11, 13, 17)
var product: SIMD[DType.int8, 4]
var overflow: SIMD[DType.bool, 4]
(product, overflow) = simd.mul_with_overflow(simd)
for i in range(len(product)):
if overflow[i]:
print("<overflow>")
else:
print(product[i])
(@lsh)
Added os.remove() and
os.unlink() for deleting files.
(@artemiogr97, fixes
#2306)
The parallel_memcpy()
function has moved from the buffer package to the algorithm package.
Please update your imports accordingly.
Optional.value() now
returns a reference instead of a copy of the contained value.
To perform a copy manually, dereference the result:
var result = Optional(123)
var value = result.value()[]
Per the accepted community proposal, Standardize the representation of byte
sequence as a sequence of unsigned 8-bit
integers,
began transition to using UInt8 by changing the data pointer of Error to
DTypePointer[DType.uint8].
(@gabrieldemarmiesse, contributes
towards #2317)
Continued transition to UnsafePointer from the legacy Pointer type
in various standard library APIs and internals.
(@gabrieldemarmiesse)
The behavior of mojo build when invoked without an output -o argument has
changed slightly: mojo build ./test-dir/program.mojo now outputs an
executable to the path ./program, whereas before it would output to the path
./test-dir/program.
The mojo package command no longer supports the -D flag. All compilation
environment flags should be provided at the point of package use (e.g.
mojo run or mojo build).
The REPL no longer allows type level variable declarations to be
uninitialized, e.g. it will reject var s: String. This is because it does
not do proper lifetime tracking (yet!) across cells, and so such code would
lead to a crash. You can work around this by initializing to a dummy value
and overwriting later. This limitation only applies to top level variables,
variables in functions work as they always have.
A low-level __get_mvalue_as_litref(x) builtin was added to give access to
the underlying memory representation as a !lit.ref value without checking
initialization status of the underlying value. This is useful in very
low-level logic but isn't designed for general usability and will likely
change in the future.
Properties can now be specified on inline MLIR ops:
_ = __mlir_op.`kgen.source_loc`[
_type = (
__mlir_type.index, __mlir_type.index, __mlir_type.`!kgen.string`
),
_properties = __mlir_attr.`{inlineCount = 1 : i64}`,
]()
As the example shows above, the protected _properties attribute can be
passed during op construction, with an MLIR DictionaryAttr value.
Support for "register only" variadic packs has been removed. Instead of
AnyRegType, please upgrade your code to AnyType in examples like this:
fn your_function[*Types: AnyRegType](*args: *Ts): ...
This move gives you access to a nicer API and has the benefit of being memory
safe and correct for non-trivial types. If you need specific APIs on the
types, please use the correct trait instead of AnyType.
List.pop_back() has been removed. Use List.pop() instead which defaults
to popping the last element in the list.
SIMD.to_int(value) has been removed. Use int(value) instead.
The __get_lvalue_as_address(x) magic function has been removed. To get a
reference to a value use Reference(x) and if you need an unsafe pointer, you
can use UnsafePointer.address_of(x).
#516 and #1817 and many others, e.g. "Can't create a function that returns two strings."
#1178 (os/kern) failure (5).
#1609 alias with
DynamicVector[Tuple[Int]] fails.
#1987 Defining main
in a Mojo package is an error, for now. This is not intended to work yet,
erroring for now will help to prevent accidental undefined behavior.
#1215 and #1949 The Mojo LSP server no longer cuts off hover previews for functions with functional arguments, parameters, or results.
#1901 Fixed Mojo LSP and documentation generation handling of inout arguments.
#1913 - 0__ no longer
crashes the Mojo parser.
#1924 JIT debugging on Mac has been fixed.
#1941 Mojo variadic arguments don't work with non-trivial register-only types.
#1963 a!=0 is now parsed
and formatted correctly by mojo format.
#1676 Fix a crash related to
@value decorator and structs with empty body.
#1917 Fix a crash after syntax error during tuple creation.
#2006 The Mojo LSP now properly supports signature types with named arguments and parameters.
#2007 and #1997 The Mojo LSP no longer crashes on certain types of closures.
#1675 Ensure @value
decorator fails gracefully after duplicate field error.
The Mojo standard library is now open source! Check out the README for everything you need to get started.
Structs and other nominal types are now allowed to implicitly conform to
traits. A struct implicitly conforms to a trait if it implements all the
requirements for the trait. For example, any struct that implements the
__str__() method implicitly conforms to Stringable, and is usable with
the str() built-in function.
@value
struct Foo:
fn __str__(self) -> String:
return "foo!"
fn main():
print(str(Foo())) # prints 'foo!'
We still strongly encourage you to explicitly list the traits a struct conforms to when possible:
@value
struct Foo(Stringable): ...
Not only is this useful for documentation and for communicating intentions, but in the future, explicit conformance will be useful for features like default methods and extensions.
Mojo's Python interoperability now supports passing keyword arguments to Python functions:
from python import Python
def main():
plt = Python.import_module("matplotlib.pyplot")
plt.plot((5, 10), (10, 15), color="red")
plt.show()
Mojo now has support for variadic keyword arguments, often referred to as
**kwargs. This means you can now declare and call functions like this:
fn print_nicely(**kwargs: Int) raises:
for key in kwargs.keys():
print(key[], "=", kwargs[key[]])
# prints:
# `a = 7`
# `y = 8`
print_nicely(a=7, y=8)
For more details (and a list of current limitations), see Variadic keyword arguments in the Mojo manual.
let declarations now produce a compile time error instead of a warning, our
next step in
removing let declarations.
The compiler still recognizes the let keyword for now in order to produce a
good error message, but that will be removed in subsequent releases.
Mojo now warns about unused values in both def and fn declarations,
instead of completely disabling the warning in defs. It never warns about
unused object or PythonObject values, tying the warning to these types
instead of the kind of function they are unused in. This will help catch API
usage bugs in defs and make imported Python APIs more ergonomic in fns.
For the time being, dynamic type values will be disabled in the language. For example, the following will now fail with an error:
var t = Int # dynamic type values not allowed
struct SomeType: ...
takes_type(SomeType) # dynamic type values not allowed
We want to take a step back and (re)design type valued variables, existentials, and other dynamic features. This does not affect type valued parameters, so the following works as before:
alias t = Int # still 🔥
struct SomeType: ...
takes_type[SomeType]() # already 🔥
>fn uses_trait[T: SomeTrait](value: T): ... # still 🔥
The *_ expression in parameter expressions is now required to occur at the
end of a positional parameter list, instead of being allowed in the middle.
# No longer supported
alias FirstUnbound = SomeStruct[*_, 42]
alias MidUnbound = SomeStruct[7, *_, 6]
# Still supported
alias LastUnbound = SomeStruct[42, *_]
We narrowed this because we want to encourage type designers
to get the order of parameters right, and want to extend *_ to support
keyword parameters as well in the future.
DynamicVector has been renamed to
List, and has moved from the
collections.vector module to the collections.list module. In addition:
You can now construct a List from a variadic number of values. For
example:
var numbers = List[Int](1, 2, 3)
List and
InlinedFixedVector
types now support negative indexing. This means that you can write vec[-1]
which is equivalent to vec[len(vec)-1].
List.push_back() has been removed. Please use the append() function
instead.
The print() function now takes sep and
end keyword arguments. This means that you can write:
print("Hello", "Mojo", sep=", ", end="!!!\n") # prints Hello, Mojo!!!
sep defaults to the empty string and end defaults to "\n".
Also, the print_no_newline() function has been removed. Please use
print(end="") instead.
The FloatLiteral type is
now an infinite-precision nonmaterializable type. This means you can do
compile-time calculations using FloatLiteral without rounding errors. When
materialized at runtime, a FloatLiteral value is converted to a
Float64.
# third is an infinite-precision FloatLiteral value
alias third = 1.0 / 3.0
# t is a Float64
var t = third
String types all conform to the
IntableRaising trait. This means
that you can now call int("123") to get the integer 123. If the integer
cannot be parsed from the string, then an error is raised.
The Tensor type now has argmax() and argmin() functions to compute the
position of the max or min value. Note: this should return a Tensor[Int] but
currently the output tensor is the same type as the input tensor. This will be
fixed in a future release.
Added a new
collections.OptionalReg
type, a register-passable alternative to
Optional.
The ulp() function has been added to the
math module. This allows you to get the units of least precision (or units
of last place) of a floating point value.
The simd_load(), simd_store(), aligned_simd_load(), and
aligned_simd_store() methods on
DTypePointer,
Buffer, and NDBuffer have been merged into
a more expressive set of load() and store() methods with keyword-only
width and alignment parameters:
# Doesn't work
my_simd = my_buffer.simd_load[simd_width](index)
# Works
my_simd = my_buffer.load[width=simd_width](index)
# Doesn't work
my_buffer.aligned_simd_store[width, alignment](my_simd)
# Works
my_buffer.store[width=width, alignment=alignment](my_simd)
The
EqualityComparable
trait now requires the __ne__() method for conformance in addition to the
previously required __eq__() method.
Many types now declare conformance to EqualityComparable trait.
StaticTuple parameter order
has changed to StaticTuple[type, size] for consistency with SIMD and
similar collection types.
The signature of the
elementwise() function has
been changed. The new order is function, simd_width, and then rank.
As a result, the rank parameter can now be inferred and one can call
elementwise() without it:
elementwise[func, simd_width](shape)
PythonObject is now register-passable.
PythonObject.__iter__() now works correctly on more types of iterable Python
objects. Attempting to iterate over non-iterable objects will now raise an
exception instead of behaving as if iterating over an empty sequence.
__iter__() also now borrows self rather than requiring inout, allowing
code like:
for value in my_dict.values():
...
We took the opportunity to rehome some modules into their correct package as we were going through the process of open-sourcing the Mojo standard library. Specifically, the following are some breaking changes worth calling out. Please update your import statements accordingly.
Buffer, NDBuffer, and friends have moved
from the memory package into a new buffer package.
from buffer import Buffer, NDBuffer
utils.list, including the Dim and
DimList types, has moved to
the buffer package.
from buffer import Dim, DimList
The parallel_memcpy()
function has moved from the memory package into the buffer package.
from buffer import parallel_memcpy
The rand() and
randn()
functions from the
random package that return a Tensor have moved to the tensor package.
Note that the overloads that write to a DTypePointer remain in the
random package.
If you happen to be using both versions in the same source file, you can
import them both using the import as syntax:
from tensor import rand
from random import rand as rand_dt
The trap() function has been renamed to
abort(). It also has moved from the debug
module to the os module.
from os import abort
The isinf() and
isfinite() methods have been moved
from math.limits to the math module.
from math import ininf, isfinite
Docstring code blocks can now use %# to hide lines of code from
documentation generation.
For example:
var value = 5
%# print(value)
Will generate documentation of the form:
var value = 5
Hidden lines are processed as if they were normal code lines during test execution. This allows for writing additional code within a docstring example that is only used to ensure the example is runnable/testable.
The Mojo LSP server now allow you to specify additional search paths to use
when resolving imported modules in a document. You can specify search paths
on the command line, using the -I option, or you can add them to the
mojo.lsp.includeDirs setting in the VS Code extension.
The __get_address_as_lvalue magic function has been removed. You can now
get an LValue from a Pointer or Reference by using the dereference
operator ([]):
var ptr: Pointer[MyRecord]
...
# Doesn't work
__get_address_as_lvalue(ptr.value) = MyRecord(3, 5)
# Works
ptr[] = MyRecord(3, 5)
The type parameter for the memcpy function is now automatically inferred.
This means that calls to memcpy of the form memcpy[Dtype.xyz](...) will
no longer work and the user would have to change the code to memcpy(...).
The memcpy() overload that worked on
Buffer types has been removed in favor of just overloads for
Pointer and
DTypePointer:
# Doesn't work
memcpy(destBuffer, srcBuffer, count)
# Works
memcpy(destBuffer.data, srcBuffer.data, count)
The functions max_or_inf(), min_or_neginf() have been removed from
math.limit. These functions were only used by the SIMD type.
As mentioned previously, the print_no_newline() function has been removed.
Please use print(end="") instead.
async and @always_inline incorrectly errored.Reference to lvalue with subtype lifetime.Optional[T].or_else() should return T instead of Optional[T].math.copysign to floating point or integral types.print
does not work when specifying end=""SIMD.reduce
methods correctly handle edge cases where size_out >= size.Mojo is now bundled with the MAX platform!
As such, the Mojo package version now matches the MAX version, which follows
a YY.MAJOR.MINOR version scheme. Because this is our first release in 2024,
that makes this version 24.1.
Mojo debugging support is here! The Mojo VS Code extension includes debugger support. For details, see Debugging in the Mojo Manual.
We now have a Set type in our
collections! Set is backed by a Dict, so it has fast add, remove, and in
checks, and requires member elements to conform to the KeyElement trait.
from collections import Set
var set = Set[Int](1, 2, 3)
print(len(set)) # 3
set.add(4)
for element in set:
print(element[])
set -= Set[Int](3, 4, 5)
print(set == Set[Int](1, 2)) # True
print(set | Set[Int](0, 1) == Set[Int](0, 1, 2)) # True
let element = set.pop()
print(len(set)) # 1
Mojo now supports the x in y expression as syntax sugar for
y.__contains__(x) as well as x not in y.
Mojo now has support for keyword-only arguments and parameters. For example:
fn my_product(a: Int, b: Int = 1, *, c: Int, d: Int = 2):
print(a * b * c * d)
my_product(3, c=5) # prints '30'
my_product(3, 5, d=7) # error: missing 1 required keyword-only argument: 'c'
This includes support for declaring signatures that use both variadic and keyword-only arguments/parameters. For example, the following is now possible:
fn prod_with_offset(*args: Int, offset: Int = 0) -> Int:
var res = 1
for i in range(len(args)):
res *= args[i]
return res + offset
print(prod_with_offset(2, 3, 4, 10)) # prints 240
print(prod_with_offset(2, 3, 4, offset=10)) # prints 34
Note that variadic keyword-only arguments/parameters (for example, **kwargs)
are not supported yet. That is, the following is not allowed:
fn variadic_kw_only(a: Int, **kwargs): ...
For more information, see Positional-only and keyword-only arguments in the Mojo Manual.
The print() function now accepts a keyword-only argument for the end
which is useful for controlling whether a newline is printed or not
after printing the elements. By default, end defaults to "\n" as before.
The Mojo SDK can now be installed on AWS Graviton instances.
A new version of the Mojo Playground is available. The new playground is a simple interactive editor for Mojo code, similar to the Rust Playground or Go Playground. The old JupyterLab based playground will remain online until March 20th.
The Mojo LSP server will now generate fixits for populating empty documentation strings:
fn foo(arg: Int):
"""""" # Unexpected empty documentation string
Applying the fixit from above will generate:
fn foo(arg: Int):
"""[summary].
Args:
arg: [description].
"""
Added new *_ syntax that allows users to explicitly unbind any number of
positional parameters. For example:
struct StructWithDefault[a: Int, b: Int, c: Int = 8, d: Int = 9]: pass
alias all_unbound = StructWithDefault[*_]
# equivalent to
alias all_unbound = StructWithDefault[_, _, _, _]
alias first_bound = StructWithDefault[5, *_]
# equivalent to
alias first_bound = StructWithDefault[5, _, _, _]
alias last_bound = StructWithDefault[*_, 6]
# equivalent to
alias last_bound = StructWithDefault[_, _, _, 6]
alias mid_unbound = StructWithDefault[3, *_, 4]
# equivalent to
alias mid_unbound = StructWithDefault[3, _, _, 4]
As demonstrated above, this syntax can be used to explicitly unbind an arbitrary number of parameters, at the beginning, at the end, or in the middle of the operand list. Since these unbound parameters must be explicitly specified at some point, default values for these parameters are not applied. For example:
alias last_bound = StructWithDefault[*_, 6]
# When using last_bound, you must specify a, b, and c. last_bound
# doesn't have a default value for `c`.
var s = last_bound[1, 2, 3]()
For more information see the Mojo Manual sections on partially-bound types and automatic parameterization of functions.
DynamicVector now supports iteration.
Iteration values are instances of Reference and require dereferencing:
var v: DynamicVector[String]()
v.append("Alice")
v.append("Bob")
v.append("Charlie")
for x in v:
x[] = str("Hello, ") + x[]
for x in v:
print(x[])
The mojo package command now produces compilation agnostic packages.
Compilation options such as O0, or --debug-level, are no longer needed or
accepted. As a result, packages are now smaller, and extremely portable.
Initializers for @register_passable values can (and should!) now be
specified with inout self arguments just like memory-only types:
@register_passable
struct YourPair:
var a: Int
var b: Int
fn __init__(inout self):
self.a = 42
self.b = 17
fn __copyinit__(inout self, existing: Self):
self.a = existing.a
self.b = existing.b
This form makes the language more consistent, more similar to Python, and easier to implement advanced features for. There is also no performance impact of using this new form: the compiler arranges to automatically return the value in a register without requiring you to worry about it.
The older -> Self syntax is still supported in this release, but will be
removed in a subsequent one, so please migrate your code. One thing to watch
out for: a given struct should use one style or the other, mixing some of
each won't work well.
The inout self initializer form is required for initializers of
@register_passable types that may raise errors:
@register_passable
struct RaisingCtor:
fn __init__(inout self) raises:
raise
async functions that may raise errors have been temporarily disabled in this
build. The implementation of Mojo async is undergoing a rework 🚧.
The standard library slice type has been renamed to
Slice, and a slice
function has been introduced. This makes Mojo closer to Python and makes the
Slice type follow the naming conventions of other types like Int.
"Slice" syntax in subscripts is no longer hard coded to the builtin slice
type: it now works with any type accepted by a container's __getitem__()
method. For example:
@value
struct UnusualSlice:
var a: Int
var b: Float64
var c: String
struct YourContainer:
fn __getitem__(self, slice: UnusualSlice) -> T: ...
Given this implementation, you can subscript into an instance of
YourContainer like yc[42:3.14:"🔥"] and the three values are passed to the
UnusualSlice constructor.
The __refitem__() accessor method may now return a Reference instead of
having to return an MLIR internal reference type.
Added
AnyPointer.move_into()
method, for moving a value from one pointer memory location to another.
Added built-in hex() function, which
can be used to format any value whose type implements the
Intable trait as a hexadecimal string.
PythonObject now
implements __is__ and __isnot__ so that you can use expressions of the
form x is y and x is not y with PythonObject.
PythonObject now conforms
to the SizedRaising trait. This means the built-in
len() function now works on PythonObject.
The os package now contains the stat()
and lstat() functions.
A new os.path package now allows you to query
properties on paths.
The os package now has a
PathLike trait. A struct conforms
to the PathLike trait by implementing the __fspath__() function.
The pathlib.Path now has functions to
query properties of the path.
The listdir() method now exists on
pathlib.Path and also exists in the os
module to work on PathLike structs. For example, the following sample
lists all the directories in the /tmp directory:
from pathlib import Path
fn walktree(top: Path, inout files: DynamicVector[Path]):
try:
var ls = top.listdir()
for i in range(len(ls)):
var child = top / ls[i]
if child.is_dir():
walktree(child, files)
elif child.is_file():
files.append(child)
else:
print("Skipping '" + str(child) + "'")
except:
return
fn main():
var files = DynamicVector[Path]()
walktree(Path("/tmp"), files)
for i in range(len(files)):
print(files[i])
The find(),
rfind(),
count(), and
__contains__()
methods now work on string literals. This means that you can write:
if "Mojo" in "Hello Mojo":
...
Breakpoints can now be inserted programmatically within the code using the
builtin breakpoint() function.
Note: on Graviton instances, the debugger might not be able to resume after hitting this kind of breakpoint.
Added a builtin Boolable trait that
describes a type that can be represented as a boolean value. To conform to the
trait, a type must implement the __bool__() method.
Modules within packages can now use purely relative from imports:
from . import another_module
Trivial types, like MLIR types and function types, can now be bound implicitly
to traits that require copy constructors or move constructors, such as
Movable,
Copyable, and
CollectionElement.
A new magic __origin_of(expr) call will yield the lifetime of a memory
value. We hope and expect that this will eventually be replaced by
Reference(expr).lifetime as the parameter system evolves, but this is
important in the meantime for use in function signatures.
A new magic __type_of(expr) call will yield the type of a value. This allows
one to refer to types of other variables. For example:
fn my_function(x: Int, y: __type_of(x)) -> Int:
let z: __type_of(x) = y
return z
As another step towards
removing let declarations
we have removed support for let declarations inside the compiler. To ease
migration, we parse let declarations as a var declaration so your code
won't break. We emit a warning about this, but please switch your code to
using var explicitly, because this migration support will be removed in a
subsequent update.
fn test():
# treated as a var, but please update your code!
let x = 42 # warning: 'let' is being removed, please use 'var' instead
x = 9
It is no longer possible to explicitly specify implicit argument parameters in automatically parameterized functions. This ability was an oversight and this is now an error:
fn autoparameterized(x: SIMD):
pass
autoparameterized[DType.int32, 1](3) # error: too many parameters
vectorize_unroll has been removed, and
vectorize now has a parameter
named unroll_factor with a default value of 1. Increasing unroll_factor
may improve performance at the cost of binary size. See the
loop unrolling blog here
for more details.
The vectorize signatures have changed with the closure func moved to the
first parameter:
vectorize[func, width, unroll_factor = 1](size)
vectorize[func, width, size, unroll_factor = 1]()
The doc string has been updated with examples demonstrating the difference between the two signatures.
The unroll signatures have changed with the closure func moved to the
first parameter:
unroll[func, unroll_count]()
The signature of the NDBuffer and Buffer types have changed. Now, both
take the type as the first parameter and no longer require the shape
parameter. This allows you to use these types and have sensible defaults.
For example:
NDBuffer[DType.float32, 3]
is equivalent to
NDBuffer[DType.float32, 3, DimList.create_unknown[3]()]
Users can still specify the static shape (if known) to the type:
NDBuffer[DType.float32, 3, DimList(128, 128, 3)]
The error message for missing function arguments is improved: instead of
describing the number of arguments (e.g. callee expects at least 3 arguments, but 1 was specified) the missing arguments are now described by
name (e.g. missing 2 required positional arguments: 'b', 'c').
The CollectionElement trait
is now a built-in trait and has been removed from collections.vector.
The DynamicVector(capacity: Int) constructor has been changed to take
capacity as a keyword-only argument to prevent implicit conversion from
Int.
Variant.get[T]() now
returns a Reference to the value rather than a copy.
The String methods tolower()
and toupper() have been renamed to str.lower() and str.upper().
The ref and mutref identifiers are no longer reserved as Mojo keywords.
We originally thought about using those as language sugar for references, but
we believe that generic language features combined with the
Reference type will provide a good
experience without dedicated sugar.
StaticTuple is constructed with a negative size for
the number of elements.self argument type in trait method declaration.inout/owned on variadic arguments.raises and capturing in functional type expressions.fn in specific contexts.SIMD.shift_left and SIMD.shift_right.A new Mojo-native dictionary type,
Dict for storing key-value pairs.
Dict stores values that conform to the
CollectionElement
trait. Keys need to conform to the new
KeyElement trait, which is
not yet implemented by other standard library types. In the short term, you
can create your own wrapper types to use as keys. For example, the following
sample defines a StringKey type and uses it to create a dictionary that maps
strings to Int values:
from collections.dict import Dict, KeyElement
@value
struct StringKey(KeyElement):
var s: String
fn __init__(inout self, owned s: String):
self.s = s ^
fn __init__(inout self, s: StringLiteral):
self.s = String(s)
fn __hash__(self) -> Int:
return hash(self.s)
fn __eq__(self, other: Self) -> Bool:
return self.s == other.s
def main():
var d = Dict[StringKey, Int]()
d["cats"] = 1
d["dogs"] = 2
print(len(d)) # prints 2
print(d["cats"]) # prints 1
print(d.pop("dogs")) # prints 2
print(len(d)) # prints 1
We plan to add KeyElement conformance to standard library types in
subsequent releases.
Users can opt-in to assertions used in the standard library code by
specifying -D MOJO_ENABLE_ASSERTIONS when invoking mojo to
compile your source file(s). In the case that an assertion is fired,
the assertion message will be printed along with the stack trace
before the program exits. By default, assertions are not enabled
in the standard library right now for performance reasons.
The Mojo Language Server now implements the References request. IDEs use this to provide support for Go to References and Find All References. A current limitation is that references outside of the current document are not supported, which will be addressed in the future.
The sys.info module now includes
num_physical_cores(), num_logical_cores(), and num_performance_cores()
functions.
Homogeneous variadic arguments consisting of memory-only types, such as
String are more powerful and easier to use. These arguments are projected
into a
VariadicListMem.
(Previous releases made it easier to use variadic lists of register-passable
types, like Int.)
Subscripting into a VariadicListMem now returns the element instead of an
obscure internal type. In addition, we now support inout and owned
variadic arguments:
fn make_worldly(inout *strs: String):
# This "just works" as you'd expect!
for i in range(len(strs)):
strs[i] += " world"
fn main():
var s1: String = "hello"
var s2: String = "konnichiwa"
var s3: String = "bonjour"
make_worldly(s1, s2, s3)
print(s1) # hello world
print(s2) # konnichiwa world
print(s3) # bonjour world
(Previous releases made it easier to use variadic lists, but subscripting into
a VariadicListMem returned a low-level pointer, which required the user to
call __get_address_as_lvalue() to access the element.)
Note that subscripting the variadic list works nicely as above, but iterating
over the variadic list directly with a for loop produces a Reference
(described below) instead of the desired value, so an extra subscript is
required; We intend to fix this in the future.
fn make_worldly(inout *strs: String):
# Requires extra [] to dereference the reference for now.
for i in strs:
i[] += " world"
Heterogeneous variadic arguments have not yet been moved to the new model, but will in future updates.
Note that for variadic arguments of register-passable types like Int, the
variadic list contains values, not references, so the dereference operator
([]) is not required. This code continues to work as it did previously:
fn print_ints(*nums: Int):
for num in nums:
print(num)
print(len(nums))
Mojo now has a prototype version of a safe
Reference type. The compiler's
lifetime tracking pass can reason about references to safely extend local
variable lifetime, and check indirect access safety. The Reference type
is brand new (and currently has no syntactic sugar) so it must be explicitly
dereferenced with an empty subscript: ref[] provides access to the
underlying value.
fn main():
var a: String = "hello"
var b: String = " references"
var aref = Reference(a)
aref[] += b
print(a) # prints "hello references"
aref[] += b
# ^last use of b, it is destroyed here.
print(aref[]) # prints "hello references references"
# ^last use of a, it is destroyed here.
While the Reference type has the same in-memory representation as a C
pointer or the Mojo Pointer type, it also tracks a symbolic "lifetime" value
so the compiler can reason about the potentially accessed set of values. This
lifetime is part of the static type of the reference, so it propagates through
generic algorithms and abstractions built around it.
The Reference type can form references to both mutable and immutable memory
objects, e.g. those on the stack or borrowed/inout/owned function arguments.
It is fully parametric over mutability, eliminating the problems with code
duplication due to mutability
specifiers and
provides the base for unified user-level types. For example, it could be
used to implement an array slice object that handles both mutable and
immutable array slices.
While this is a major step forward for the lifetimes system in Mojo, it is still very early and awkward to use. Notably, there is no syntactic sugar for using references, such as automatic dereferencing. Several aspects of it need to be more baked. It is getting exercised by variadic memory arguments, which is why they are starting to behave better now.
Note: the safe Reference type and the unsafe pointer types are defined in
the same module, currently named memory.unsafe. We expect to restructure
this module in a future release.
Mojo now allows types to implement __refattr__() and __refitem__() to
enable attribute and subscript syntax with computed accessors that return
references. For common situations where these address a value in memory this
provides a more convenient and significantly more performant alternative to
implementing the traditional get/set pairs. Note: this may be changed in the
future when references auto-dereference—at that point we may switch to just
returning a reference from __getattr__().
Parametric closures can now capture register passable typed values by copy
using the __copy_capture decorator. For example, the following code will
print 5, not 2.
fn foo(x: Int):
var z = x
@__copy_capture(z)
@parameter
fn formatter() -> Int:
return z
z = 2
print(formatter())
fn main():
foo(5)
String now implements KeyElement and may be used as a key in Dict.
More robust support for structs with fields of self referencing types.
For example, the following code will work and print 0:
struct Foo(CollectionElement):
var vec: DynamicVector[Self]
fn __init__(inout self: Self):
self.vec = DynamicVector[Self]()
fn __moveinit__(inout self: Self, owned existing: Self):
self.vec = existing.vec ^
fn __copyinit__(inout self: Self, existing: Self):
self.vec = existing.vec
fn main():
var foo = Foo()
print(len(foo.vec))
The __takeinit__ special constructor form has been removed from the
language. This "non-destructive move" operation was previously wired into the
x^ transfer operator, but had unpredictable behavior that wasn't consistent.
Now that Mojo has traits, it is better to model this as an explicit .take()
operation on a type, which would transfer out the contents of the type without
ending its lifetime. For example, for a type that holds a pointer, take()
might return a new instance pointing to the same data, and null out its own
internal pointer.
This change makes it clear when a lifetime is ended versus when the contents of an LValue are explicitly taken.
The current implementation of autotuning has been deprecated, as Mojo's autotuning implementation is undergoing a redesign. Tutorials around the current implementation have also been removed as they are being rewritten.
Consequently, the autotune(), autotune_fork(), and search() functions
have been removed from the standard library.
The _OldDynamicVector type that worked only on register passable element
types has been removed. Please migrate uses to
DynamicVector which
works on both register passable and memory types.
The UnsafeFixedVector in utils.vector has been removed. We recommend using
either DynamicVector
or InlinedFixedVector
instead.
The @adaptive decorator has been removed from the language. Any uses of the
decorator in a non-search context can be replaced with @parameter if. For
example:
@adaptive
fn foo[a: Bool]():
constrained[a]()
body1()
@adaptive
fn foo[a: Bool]():
constrained[not a]()
body2()
Can be rewritten as:
fn foo[a: Bool]():
@parameter
if a:
body1()
else:
body2()
Consequently, the special __adaptive_set attribute has been removed as well.
Result parameters have been removed from Mojo. Result parameter declarations
in function parameter lists are no longer allowed, nor are forward alias
declarations. This includes removing the param_return statement.
The @noncapturing and @closure decorators have been removed due to
refinements and improvements to the closure model. See below for more details!
The Mojo closure model has been refined to be more straightforward and safe.
Mojo has two closure types: parameter closures and runtime closures. Parameter
closures can be used in higher-order functions and are the backbone of
functions like vectorize and parallelize. They are always denoted by
@parameter and have type fn() capturing -> T (where T is the return
type).
On the other hand, runtime closures are always dynamic values, capture values by invoking their copy constructor, and retain ownership of their capture state. You can define a runtime closure by writing a nested function that captures values:
fn outer(b: Bool, x: String) -> fn() escaping -> None:
fn closure():
print(x) # 'x' is captured by calling String.__copyinit__
fn bare_function():
print("hello") # nothing is captured
if b:
# closure can be safely returned because it owns its state
return closure^
# function pointers can be converted to runtime closures
return bare_function
The type of runtime closures are of the form fn() escaping -> T. You
can pass equivalent function pointers as runtime closures.
Stay tuned for capture list syntax for move capture and capture by reference, and a more unified closure model!
The @unroll(n) decorator can now take a parameter expression for
the unroll factor, i.e. n can be a parameter expression that is
of integer type.
The cpython module in the python package has been moved to be an internal
module, i.e, _cpython.
AnyType and Destructable have been unified into a single trait, AnyType.
Every nominal type (i.e. all structs) now automatically conform to AnyType.
Previously, the mojo package command would output a Mojo package that
included both partly-compiled Mojo code, as well as fully-compiled machine
code for a specific computer architecture -- the architecture of the machine
being used to invoke the mojo package command.
Now, mojo package only includes partly-compiled Mojo code. It is only fully
compiled for the specific computer architecture being used at the point that
the package is first import-ed. As a result, Mojo packages are smaller and
more portable.
The simd_width and dtype parameters of polynomial_evaluate have been
switched. Based on the request in
#1587, the
polynomial_evaluate function has also been extended so that the
coefficients parameter can take either a either a
StaticTuple or a
VariadicList.
As a tiny step towards removing let declarations, this release removes the
warning: 'var' was never mutated, consider switching to a 'let'.
IntLiteral in runtime code.self before it was initialized when exiting with an
error.or expressions.AnyPointer.self
argument when overloading operators using dunder methods.DynamicVector copy constructor in certain situations.benchmark.keep
function now properly handles vector types.simd.shuffle
operation now works on 64 element permutations.String.find()
returning wrong value when starting index is non-zero.String.replace() returning incorrect results for multi-character search
strings.field 'w.x.y' destroyed out of the middle of a value, preventing the overall value from being destroyed.AnyType struct member.mojo-lldb, to prevent name collisions with the system's
LLDB.@unroll does not
accept alias as unroll factor.The Mojo REPL now provides limited support for the %cd magic command.
This command automatically maintains an internal stack of directories you visit during the REPL session. Usage:
%cd 'dir': change to directory dir and push it on the directory stack.%cd -: pop the directory stack and change to the last visited directory.Structs decorated with @value now automatically conform to the
Movable
and Copyable built-in traits.
String now has new
toupper() and
tolower() methods
analogous, respectively, to Python's str.toupper() and str.tolower().
Added a hash() built-in function and
Hashable trait for types
implementing the __hash__() method. Future releases will add Hashable
support to Standard Library types. In the meantime, the hash module includes
a version of the hash() function that works on arbitrary byte strings. To
generate hashes for SIMD types, you
use the internal _hash_simd() function:
from builtin.hash import _hash_simd
fn gen_simd_hash():
let vector = SIMD[DType.int64, 4](1, 2, 3, 4)
let hash = _hash_simd(vector)
Several standard library types now conform to the
CollectionElement trait. These
types include Bool,
StringLiteral,
DynamicVector, Tensor, TensorShape,
and TensorSpec.
utils.vector has been moved to a new collections package to make
space for new collections. This means that if you had previous code
that did from utils.vector import DynamicVector, it now needs to
be from collections.vector import DynamicVector due to the move.
The special destructor method __del__() has been changed to enforce
that it cannot raise an error. Raising destructors are not supported properly
at the moment.
#1421 - Fixed a crash when using Tuples in the REPL.
#222 - Generate an error for obviously self recursive functions.
#1408 - Fix overload resolution when candidates can return generic types.
#1413 and #1395 - Do not crash when re-declaring a builtin declaration.
#1307 - Fix compatibility of function signatures that only differ in default argument values.
#1380 - Fix printing
of empty String.
Traits have arrived!
You can now define a trait, which consists of a required set of method prototypes. A struct can conform to the trait by implementing these methods. This lets you write generic functions that work on any structs that conform to a given trait.
The following section gives a brief overview of traits—see the Mojo Manual and this traits blog post for more details!
Traits are declared with the trait keyword. The bodies of traits should
contain method signatures declared with ... as their bodies. Default
method implementations are not supported yet.
trait SomeTrait:
fn required_method(self, x: Int): ...
The trait can be implemented on a struct by inheriting from it.
struct SomeStruct(SomeTrait):
fn required_method(self, x: Int):
print("hello traits", x)
You can then write a generic functions that accepts any type that conforms to the trait. You do this by creating a parameterized function with a trait-typed parameter:
fn fun_with_traits[T: SomeTrait](x: T):
x.required_method(42)
Which can be invoked with instances of types that conform to the trait:
var thing = SomeStruct()
# Infer the parameter `T`!
fun_with_traits(thing)
Traits can also inherit from other traits, which simply requires that implementers of the child trait also conform to all parent traits.
trait Parent:
fn parent_func(self): ...
trait Child(Parent):
fn child_func(self): ...
Then, both child and parent trait methods can be invoked on instances of
the trait Child. As well, an instance of the child trait can be converted to
an instance of the parent trait.
fn the_parents[T: Parent](x: T):
x.parent_func()
fn the_children[T: Child](x: T):
x.child_func()
x.parent_func()
# Upcast `x` from instance of `Child` to `Parent`.
the_parents(x)
For more information, see the Traits page in the Mojo Manual.
A fundamental Destructable trait has been added to the language. This is a
core trait that every trait automatically conforms to. This enables
destruction of generic types and generic collections.
Note: We're aware that this trait might be better spelled Destructible.
We're planning on removing it in the future and moving its functionality to
AnyType so that any type that doesn't provide its own destructor will have
a default, no-op destructor.
We've added some traits to the standard library, you can implement these on your own types:
We added built-in len(), str(), and
int() functions, which work with types that implement the Sized,
Stringable, and Intable traits, respectively.
DynamicVector is now a
proper generic collection that can use any type that implements the Movable
and Copyable traits. This means you can now write, for example,
DynamicVector[String]. Also, DynamicVector now invokes its element
destructors upon destruction, so _del_old has been deleted.
print now works on any types that implement Stringable by invoking their
__str__ method:
@value
struct BoxedInt(Stringable):
var value: Int
fn __str__(self) -> String:
return self.value
print(BoxedInt(11), "hello traits!", BoxedInt(42))
The Mojo Manual is an all-new, complete Mojo user guide. It doesn't include everything about Mojo yet, but it includes a lot, and more than the original programming manual (now deprecated).
Plus, the entire Mojo Manual and other Mojo docs are now open-sourced on GitHub, and we'd love to accept contributions to help us improve them!
Mojo now supports partial automatic parameterization: when a function is declared with an argument of a partially bound type, the unbound parameters of that type are implicitly added to the function's input parameters. For example:
@value
struct Fudge[a: Int, b: Int, c: Int = 7]: ...
# These function declarations are roughly equivalent:
fn eat(f: Fudge[5]): ... # implicitly parameterized
fn eat[_b: Int](f: Fudge[5, _b]): ... # explicitly parameterized
In the first signature for eat(), the b parameter isn't bound, so it's
implicitly added as an input parameter on the function.
In the second signature for eat(), the author has explicitly defined an
input parameter (_b), which is bound to the second parameter on the argument
type (which happens to be b).
Both functions can be called like this:
eat(Fudge[5, 8]())
Mojo infers the value of the b parameter from the argument (in this case,
8).
With the second signature, you can also pass the _b parameter value
explicitly:
eat[3](Fudge[5, 3]())
Moreover, Mojo now allows you to explicitly mark parameters as unbound using
the _ as syntax meaning "placeholder for an unbound parameter." For example:
# These function declarations are roughly equivalent:
fn eat(f: Fudge[5, _, c=_]): ... # implicitly parameterized
fn eat(f: Fudge[c=_, a=5, b=_]): ... # implicitly parameterized
fn eat[_b: Int, _c: Int](f: Fudge[5, _b, _c]): ... # explicitly parameterized
The first two signatures explicitly unbind the b and c parameters.
In the last signature, the _b and _c parameters are explicitly declared by
the author, and bound to the b and c parameters in the argument type.
Any of these signatures can be called like this:
eat(Fudge[5, 8]())
eat(Fudge[5, 8, 9]())
Note that the default parameter values of struct parameters are bound, unless explicitly unbound by the user.
For more information, see the Mojo Manual.
Parametric types can now be partially bound in certain contexts. For example,
a new Scalar type alias has been added defined as:
alias Scalar = SIMD[size=1]
Which creates a parametric type alias Scalar with a single parameter of type
DType. Types can also be partially or fully bound in other contexts. For
instance, alias declarations of type values inside functions now work
properly:
fn type_aliases():
alias T = SIMD
print(T[DType.float32, 1]())
alias Partial = T[type=DType.int32]
print(Partial[2]())
The __mlir_op feature now supports operations that return multiple results.
To use them, you write the _type field as a Tuple of types. For example:
# The `ret` variable has type `Tuple[Int, Int]`.
let ret = __mlir_op.`multi_result_op`[_type=(Int, Int)]()
Mojo now has the ability to read raw bytes from a file using the
read_bytes() method.
For example:
with open("file.binary", "r") as f:
data = f.read_bytes()
A size argument was added to the
read() and
read_bytes() methods on
the builtin file.FileHandle. The size argument defaults to -1 and maintains
the previous "read to EOF" behavior when size is negative.
with open("file.binary", "r") as f:
data1 = f.read_bytes(1024)
data2 = f.read_bytes(256)
Path now has read_bytes() and
read_text() methods to read file contents from a path:
let text_path = Path("file.txt")
let text = text_path.read_text()
let binary_path = Path("file.binary")
let data = binary_path.read_bytes()
Tensor has new save() and load() methods to save and load to file. These
methods preserve shape and datatype information. For example:
let tensor = Tensor[DType.float32]()
tensor.save(path)
let tensor_from_file = Tensor[DType.float32].load(path)
Subscripting added to
DTypePointer and
Pointer:
let p = DTypePointer[DType.float16].alloc(4)
for i in range(4):
p[i] = i
print(p[i])
file.FileHandle now has a seek() method.
String now has an
rfind() method
analogous to Python's str.rfind().
String now has an
split() method
analogous to Python's str.split().
Path now has a
suffix() method analogous to
Python's pathlib.Path.suffix.
The Mojo REPL now supports indented expressions, making it a bit easier to execute expressions copied from an indented block (such as a doc string).
The Mojo Language Server now implements the Document Symbols request. IDEs use this to provide support for Outline View and Go to Symbol. This addresses Issue #960.
The Mojo Language Server now shows documentation when code completing modules
or packages in import statements.
The Mojo Language Server now supports processing code examples, defined as markdown Mojo code blocks, inside of doc strings. This enables IDE features while writing examples in API documentation.
The Mojo Language Server now provides semantic token information, providing better highlighting for symbols whose semantics are not statically analyzable.
The Mojo Language Server now classifies doc strings as folding ranges, making them easier to collapse, reducing vertical space while editing.
Command line options for the mojo driver that take arguments can now be
written in either of two ways: both --foo FOO and --foo=FOO. Previously,
only the former was valid.
Variadic list types
VariadicList and
VariadicListMem
are now iterable. Variadic arguments are automatically projected into one of
these types inside the function body, so var args can be iterated:
fn print_ints(*nums: Int):
for num in nums:
print(num)
print(len(nums))
The assert functions in the testing
package now raise an Error when the assertion fails instead of returning a
Bool for whether the assertion succeeded or not.
Parameters of AnyType type are no
longer (implicitly) assumed to be register-passable. A new AnyRegType type
is used to represent generic types that are register passable.
Changing the units in a benchmark
report is now an argument instead of a parameter:
let report = benchmark.run[timer]()
report.print(Unit.ms)
Default values on inout arguments are no longer permitted, i.e. the
following will now raise an error:
fn inout_default(inout x: Int = 2): ...
The to_string() function has been removed from
PythonObject in favor of
the new __str__() function. This composes better with traits so it can be
used with the generic str() function.
#734 - Consumption of struct
works only for types with a __del__ method.
#910 - Parser crash when
using memory-only generic type as return of function that raises.
#1060 - Mojo happily parses code that has messed up indentation
#1159 - The language server doesn't warn about bad return type.
#1166 - warning: unreachable code after return statement with context manager
#1098 - The language server doesn't highlight properties of PythonObjects correctly.
#1153 - The language server crashes when parsing an invalid multi-nested module import.
#1236 - The language server doesn't show autocomplete in if statements.
#1246 - Warning diagnostics are transient in the presence of caching.