Mojo🔥 changelog
This is a list of changes to the Mojo language, standard library, and tools.
To check your current version, run mojo --version
. To update the version of
Mojo for your project with the magic
package manager, follow the instructions
in Update a package to update the max
package.
v24.5 (2024-09-13)
✨ Highlights
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 theFormattable
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 adef
. Thevar
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
, andPointer
have been removed. UseUnsafePointer
instead. Functions that previously took aDTypePointer
now take an equivalentUnsafePointer
. 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.
Language changes
-
Mojo now allows implicit definitions of variables within a
fn
in the same way that has been allowed in adef
. Thevar
keyword is still allowed and still denotes the declaration of a new variable with a scope (in bothdef
andfn
). Relaxing this makesfn
anddef
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()
# error: passing `my_string` inout is invalid since it is also passed
# borrowed.
take_two_strings(my_string, my_string)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()
# error: 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.
note -
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())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.@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"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): ...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. turningyourType[1, 2] = 3
intoyourType.__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 functionfn __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 uninitializeddef 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 (likeString
,List
, etc.) andraises
. Accordingly, bothCoroutine
andRaisingCoroutine
have been changed to acceptAnyType
instead ofAnyTrivialRegType
. This means the result types ofasync
functions do not need to beMovable
.async fn raise_or_string(c: Bool) raises -> String:
if c:
raise "whoops!"
return "hello world!"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"
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"
export MOJO_PYTHON="~/venv/bin/python"
MOJO_PYTHON_LIBRARY
still exists for environments with a dynamiclibpython
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 anaddress
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.
Standard library changes
-
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 asOptional
,Variant
, and functions such asabort()
,alignof()
,bitcast()
,bitwidthof()
,external_call()
,simdwidthof()
, andsizeof()
). -
Some types from the
builtin
module have been moved to different modules for clarity which is made possible now that we have aprelude
module that can re-export symbols from modules other thanbuiltin
.In particular, the
builtin.string
module has been moved tocollections.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 + "!")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 theFormattable
trait. This enables efficient stream-based writing by default, avoiding unnecessary intermediate String heap allocations.Previously,
print()
required types conform toStringable
. This meant that to execute a call likeprint(a, b, c)
, at least three separate String heap allocations were down, to hold the formatted values ofa
,b
, andc
respectively. The total number of allocations could be much higher if, for example,a.__str__()
was implemented to concatenate together the fields ofa
, 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) + ")"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, ")")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 aString
from a type that implementsFormattable
. This pattern of implementing a type'sStringable
implementation in terms of itsFormattable
implementation minimizes boilerplate and duplicated code, while retaining backwards compatibility with the requirements of the commonly usedstr()
function.note -
debug_assert()
now also requires that itsmessage
argument conform toFormattable
. -
Added
TemporaryDirectory
in moduletempfile
. (PR 2743) -
Added
NamedTemporaryFile
in moduletempfile
. (PR 2762)
-
-
String
and friends:-
The
builtin.string
module has been moved tocollections.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("{1} Welcome to {0} {1}").format("mojo", "🔥")
)
# 🔥 Wecome to mojo 🔥print(String("{} {} {}").format(True, 1.125, 2))
#True 1.125 2print(String("{} {} {}").format(True, 1.125, 2))
#True 1.125 2 -
String.format()
now supports conversion flags!s
and!r
, allowing forstr()
andrepr()
conversions within format strings. (PR #3279)Example:
String("{} {!r}").format("Mojo", "Mojo")
# "Mojo 'Mojo'"
String("{0!s} {0!r}").format("Mojo")
# "Mojo 'Mojo'"String("{} {!r}").format("Mojo", "Mojo")
# "Mojo 'Mojo'"
String("{0!s} {0!r}").format("Mojo")
# "Mojo 'Mojo'" -
The
String
class now hasrjust()
,ljust()
, andcenter()
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 toString
andStringLiteral
, which returns anUnsafePointer[C_char]
for convenient interoperability with C APIs. -
Added the
byte_length()
method toString
,StringSlice
, andStringLiteral
and deprecated their private_byte_length()
methods. Added a warning to theString.__len__()
method that it will return the length in Unicode codepoints in the future andStringSlice.__len__()
now does return the Unicode codepoints length. (PR #2960) -
Added a new
StaticString
type alias. This can be used in place ofStringLiteral
for runtime string arguments. -
Added a
StringSlice
initializer that accepts aStringLiteral
. -
The
StringRef
constructors fromDTypePointer.int8
have been changed to take aUnsafePointer[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 anUnsafePointer[UInt8]
(wasUnsafePointer[Int8]
) -
StringLiteral.unsafe_ptr()
now returns anUnsafePointer[UInt8]
(wasUnsafePointer[Int8]
)
-
-
-
UnsafePointer
and other reference type changes:-
DTypePointer
,LegacyPointer
, andPointer
have been removed. UseUnsafePointer
instead. For more information on using pointers, see Unsafe pointers in the Mojo Manual.Functions that previously took a
DTypePointer
now take an equivalentUnsafePointer
. A quick rule for conversion fromDTypePointer
toUnsafePointer
is:DTypePointer[type] -> UnsafePointer[Scalar[type]]
DTypePointer[type] -> UnsafePointer[Scalar[type]]
There could be places that you have code of the form:
fn f(ptr: DTypePointer):
fn f(ptr: DTypePointer):
which is equivalent to
DTypePointer[*_]
. In this case you would have to add an infer-onlytype
parameter to the function:fn f[type: DType, //](ptr: UnsafePointer[Scalar[type]]):
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 toUnsafePointer[NoneType/Int]
. But since these are not anUnsafePointer
that stores aScalar
, you might have torebind/bitcast
to appropriate types. -
The
DTypePointer
load()
andstore()
methods have been moved toUnsafePointer
. -
UnsafePointer
now supportsstrided_load()
,strided_store()
,gather()
, andscatter()
when the underlying type isScalar[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)
new_ptr = ptr.offset(1)
Becomes:
new_ptr = ptr + 1
new_ptr = ptr + 1
-
UnsafePointer
now has analignment
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[type].alloc[alignment](x) # now becomes
UnsafePointer[type, alignment].alloc(x) -
UnsafePointer
has a newexclusive: 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
toUnsafePointer
. Instead ofUnsafePointer(someRef)
please use theUnsafePointer.address_of(someRef[])
which makes the code explicit that theUnsafePointer
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)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]")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 implementssetdefault()
, which gets a value from the dictionary by key, or sets it to a default if it doesn't exist. (PR #2803) -
Dict
now supportspopitem()
, which removes and returns the last item in theDict
. (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) entriesvar 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()
andpathlib.Path.exapanduser()
have been added to allow expanding a prefixed~
in aString
orPath
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)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 intohead, tail
:import os
head, tail = os.path.split("/this/is/head/tail")
print("head:", head)
print("tail:", tail)
# head: /this/is/head
# tail: tailimport os
head, tail = os.path.split("/this/is/head/tail")
print("head:", head)
print("tail:", tail)
# head: /this/is/head
# tail: tail -
os.makedirs()
andos.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)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')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 toBool
. A newImplicitlyBoolable
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 asfn() -> 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 asmin()
/max()
, as well asmath
functions likeceildiv()
,align_down()
, andalign_up()
are also implemented forUInt
. -
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 insys.ffi
. -
sort()
now supports astable
parameter. It can be called bysort[cmp_fn, stable=True](list)
sort[cmp_fn, stable=True](list)
The algorithm requires auxiliary memory. If extra memory allocation fails, the program crashs.
-
sort()
no longer takesLegacyPointer
since that type is now removed. -
Added the
oct()
builtin function for formatting an integer in octal. (PR #2914) -
Added the
assert_is()
andassert_is_not()
test functions to thetesting
module. -
The
math
package now includes thepi
,e
, andtau
constants (Closes Issue #2135). -
The
ulp
function fromnumerics
has been moved to themath
module. -
bit
module now supportsbit_reverse()
,byte_swap()
, andpop_count()
for theInt
type. (PR #3150) -
A few
bit
functions have been renamed for clarity:-
countl_zero()
->count_leading_zeros()
-
countr_zero()
->count_trailing_zeros()
-
-
Slice
now usesOptionalReg[Int]
forstart
andend
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 emptySlice.end
option. (PR #2495)var s = Slice(1, None, 2)
print(s.start.value()) # must retrieve the value from the optionalvar s = Slice(1, None, 2)
print(s.start.value()) # must retrieve the value from the optional -
The
rank
argument foralgorithm.elementwise()
is no longer required and is only inferred. -
The
time.now()
function has been deprecated. Please usetime.perf_counter()
ortime.perf_counter_ns
instead. -
SIMD
construction fromBool
has been restricted toDType.bool
data type.
-
Tooling changes
-
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 asmojo build
. -
You can now debug unit tests using
mojo test
by passing the--debug
flag. Most debug flags are supported; runmojo 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 tomojo 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 anyraise
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.
❌ Removed
-
Support for the legacy
fn __init__(...) -> Self:
form has been removed from the compiler, please switch to usingfn __init__(inout self, ...):
instead. -
The builtin
tensor
module has been removed. Identical functionality is available inmax.tensor
, but it is generally recommended to use structs from thebuffer
module when possible instead. -
Removed
String.unsafe_uint8_ptr()
.String.unsafe_ptr()
now returns the same thing. -
Removed
StringLiteral.unsafe_uint8_ptr()
andStringLiteral.as_uint8_ptr()
. -
Removed
SIMD.splat(value: Scalar[type])
. Use the constructor forSIMD
instead. -
Removed the
SIMD.{add,mul,sub}_with_overflow()
methods. -
Removed the
SIMD.min()
andSIMD.max()
methods. Identical functionality is available using the builtinmin()
andmax()
functions. -
Removed the Mojo Language Server warnings for unused function arguments.
-
Run Mojo File in Dedicated Terminal
action has been removed, and the actionRun Mojo File
will always open a dedicated terminal for each mojo file to guarantee a correct environment.
🛠️ Fixed
-
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
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
Special thanks to our community contributors: @jjvraw, @artemiogr97, @martinvuyk, @jayzhan211, @bgreni, @mzaks, @msaelices, @rd4com, @jiex-liu, @kszucs, @thatstoasty
v24.4 (2024-06-07)
✨ Highlights
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.
Language changes
-
Mojo has changed how
def
function arguments are processed. Previously, by default, arguments to adef
were treated according to theowned
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 asborrowed
by default (consistent withfn
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, usinga,b,c = foo()
. For example:def return_two(i: Int) -> (Int, Int):
return i, i+1
a, b = return_two(5)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()
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[__lifetime_of(self)] Int:
return self.first
fn show_mutation():
var somePair = Pair(5, 6)
somePair.get_first_ref() = 1@value
struct Pair:
var first: Int
var second: Int
fn get_first_ref(inout self) -> ref[__lifetime_of(self)] Int:
return self.first
fn show_mutation():
var somePair = Pair(5, 6)
somePair.get_first_ref() = 1This 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)]()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 intovalue
, the first parameter that isn't infer-only.dt
is inferred from the parameter itself to beDType.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`
passstruct ScalarContainer[dt: DType, //, value: Scalar[dt]]:
pass
fn foo(x: ScalarContainer[Int32(0)]): # 'dt' is inferred as `DType.int32`
passThis 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!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!@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!")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 beInt
. The intention is to lift these restrictions in the future. -
The
is_mutable
parameter ofReference
andAnyLifetime
is now aBool
, 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 likeconda
and have access to Python modules installed in that environment without settingMOJO_PYTHON_LIBRARY
. Previously Mojo would find alibpython
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 toAnyTrivialRegType
and Mojo now forbids binding non-trivial register-passable types toAnyTrivialRegType
. This closes a major safety hole in the language. Please useAnyType
for generic code going forward. -
The
let
keyword has been completely removed from the language. We previously removedlet
declarations but still provided an error message to users. Now, it is completely gone from the grammar.
Standard library changes
-
New traits and related features:
-
Added built-in
repr()
function andRepresentable
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-inindex()
function to be called on them. Most standard library containers can now be indexed by any type that implementsIndexer
. 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`@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 takeInt
instead of making them take a generic type that conforms toIndexer
. 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@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 theCeilDivable
trait orCeilDivableRaising
trait. -
Due to ongoing refactoring, the traits
Ceilable
,CeilDivable
,Floorable
, andTruncable
do not appear in the API reference. They should be imported from themath
module, except forTruncable
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))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:
- The
bencher
module as part of thebenchmark
package is now public and documented. This module provides types such asBencher
which provides the ability to execute aBenchmark
and allows for benchmarking configuration via theBenchmarkConfig
struct.
- The
-
String
and friends:-
Breaking. Implicit conversion to
String
is now removed for builtin classes/types. Usestr()
explicitly to convert toString
. -
Added
String.isspace()
method conformant with Python's universal separators. This replaces theisspace()
free function from thestring
module. (If you need the old function, it is temporarily available as_isspace()
. It now takes aUInt8
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()
andrstrip()
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 asplitlines()
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 toInlineString
to be consistent with other types. -
StringRef
now implementsstrip()
, which can be used to remove leading and trailing whitespace. (PR #2683) -
StringRef
now implementsstartswith()
andendswith()
. (PR #2710) -
Added a new
StringSlice
type, to replace uses of the unsafeStringRef
type in standard library code.StringSlice
is a non-owning reference to encoded string data. UnlikeStringRef
, aStringSlice
is safely tied to the lifetime of the data it points to.- Added new
as_string_slice()
methods toString
andStringLiteral
. - Added
StringSlice
initializer from anUnsafePointer
and a length in bytes.
- Added new
-
Added a new
as_bytes_slice()
method toString
andStringLiteral
, which returns aSpan
of the bytes owned by the string. -
Continued transition to
UnsafePointer
and unsigned byte type for strings:- Renamed
String._as_ptr()
toString.unsafe_ptr()
, and changed return type toUnsafePointer
(wasDTypePointer
). - Renamed
StringLiteral.data()
toStringLiteral.unsafe_ptr()
, and changed return type toUnsafePointer
(wasDTypePointer
). InlineString.as_ptr()
has been renamed tounsafe_ptr()
and now returns anUnsafePointer[UInt8]
(wasDTypePointer[DType.int8]
).StringRef.data
is now anUnsafePointer
(wasDTypePointer
) andStringRef.unsafe_ptr()
now returns anUnsafePointer[UInt8]
(wasDTypePointer[DType.int8]
).
- Renamed
-
-
Other built-ins:
-
The
Slice.__len__()
function has been removed andSlice
no longer conforms to theSized
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 theSlice.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 theComparableCollectionElement
trait.(PR #2609) -
int()
can now take a string and a specified base to parse an integer from a string:int("ff", 16)
returns255
. 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 aString
to afloat64
. (PR #2649) -
You can now use the built-in
any()
andall()
functions to check for truthy elements in a collection. BecauseSIMD.__bool__()
is now constrained tosize=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 ofSIMD
toBool
. (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")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") -
Tuple
now supports__contains__()
. (PR #2709) For example:var x = Tuple(1, 2, True)
if 1 in x:
print("x contains 1")var x = Tuple(1, 2, True)
if 1 in x:
print("x contains 1") -
ListLiteral
andTuple
now only require that element types beMovable
. Consequently,ListLiteral
andTuple
are themselves no longerCopyable
. -
Added new
ImmutableStaticLifetime
andMutableStaticLifetime
helpers.
-
-
UnsafePointer
and others:-
Added new
memcpy()
overload forUnsafePointer[Scalar[_]]
pointers. -
Removed the
get_null()
method fromUnsafePointer
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 tounsafe_ptr()
. The return type is still aDTypePointer[T]
.
-
-
Collections:
-
List
now has anindex()
method that allows you to find the (first) location of an element in aList
ofEqualityComparable
types. For example:var my_list = List[Int](2, 3, 5, 7, 3)
print(my_list.index(3)) # prints 1var my_list = List[Int](2, 3, 5, 7, 3)
print(my_list.index(3)) # prints 1 -
List
can now be converted to aString
with a simplified syntax:var my_list = List[Int](2, 3)
print(my_list.__str__()) # prints [2, 3]var my_list = List[Int](2, 3)
print(my_list.__str__()) # prints [2, 3]Note that
List
doesn't conform to theStringable
trait yet so you cannot usestr(my_list)
yet. (PR #2673) -
List
has a simplified syntax to call thecount()
method:my_list.count(x)
. (PR #2675) -
List()
now supports__contains__()
, so you can now use lists with thein
operator:if x in my_list:
if x in my_list:
(PR #2667)
-
List
now has anunsafe_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 toDict
to return aDict
with the specified keys and values. (PR 2622) -
Dict
now supportsreversed()
for itsitems()
andvalues()
iterators. (PR #2340) -
Dict
now has a simplified conversion toString
withmy_dict.__str__()
. Note thatDict
does not conform to theStringable
trait sostr(my_dict)
is not possible yet. (PR #2674) -
Dict
now implementsget(key)
andget(key, default)
functions. (PR #2519) -
Added a temporary
__get_ref(key)
method toDict
, allowing you to get aReference
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 usingmkdir()
andrmdir()
. (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, withgettempdir()
andmkdtemp()
functions. (PR 2742)
-
-
SIMD
type:-
Added
SIMD.shuffle()
withStaticIntTuple
mask. (PR #2315) -
SIMD.__bool__()
is constrained such that it only works whensize
is1
. For SIMD vectors with more than one element, useany()
orall()
. (PR #2502) -
The
SIMD.reduce_or()
andSIMD.reduce_and()
methods are now bitwise operations, and support integer types. (PR #2671) -
Added
SIMD.__repr__()
to get the verbose string representation ofSIMD
types. (PR #2728)
-
-
math
package:-
The
math.bit
module has been moved to a new top-levelbit
module. The following functions in this module have been renamed:ctlz
->countl_zero
cttz
->countr_zero
bit_length
->bit_width
ctpop
->pop_count
bswap
->byte_swap
bitreverse
->bit_reverse
-
The
math.rotate_bits_left()
andmath.rotate_bits_right()
functions have been moved to thebit
module. -
The
is_power_of_2()
function in themath
module is now calledis_power_of_two()
and located in thebit
module. -
The
abs()
,round()
,min()
,max()
,pow()
, anddivmod()
functions have moved frommath
tobuiltin
, so you no longer need to import these functions. -
The
math.tgamma()
function has been renamed tomath.gamma()
to conform with Python's naming. -
The implementation of the following functions have been moved from the
math
module to the newutils.numerics
module:isfinite()
,isinf()
,isnan()
,nan()
,nextafter()
, andulp()
. The functions continue to be exposed in themath
module. -
math.gcd()
now works on negative inputs, and like Python's implementation, accepts a variadic list of integers. New overloads for aList
orSpan
of 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 existingStaticTuple
type, which is conceptually an array type, but only works onAnyTrivialRegType
. (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 inVariant
andOptional
has been renamed tounsafe_take()
. -
The
get()
function inVariant
has been replaced by__getitem__()
. That is,v.get[T]()
should be replaced withv[T]
. -
Various functions in the
algorithm
module are now built-in functions. This includessort()
,swap()
, andpartition()
.swap()
andpartition()
will likely shuffle around as we're reworking our built-insort()
function and optimizing it.
-
-
infinity
andNaN
are now correctly handled intesting.assert_almost_equal()
and aninf
function has been added toutils/numerics.mojo
. (PR #2375)
Tooling changes
-
Invoking
mojo package my-package -o my-dir
on the command line, wheremy-package
is a Mojo package source directory, andmy-dir
is an existing directory, now outputs a Mojo package tomy-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
, andmojo test
. Further, themojo test --json
option has been subsumed into this new option; for the same behavior, runmojo 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 tomojo
to emit errors on invalid doc strings instead of warnings. -
The
--warn-missing-doc-strings
flag formojo
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 ofmojo 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.
Other changes
❌ Removed
-
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. Sinceobject
now conforms to theStringable
trait, you can useprint(my_object)
instead. -
The following functions have been removed from the math module:
clamp()
; use the newSIMD.clamp()
method instead.round_half_down()
andround_half_up()
; these can be trivially implemented using theceil()
andfloor()
functions.add()
,sub()
,mul()
,div()
,mod()
,greater()
,greater_equal()
,less()
,less_equal()
,equal()
,not_equal()
,logical_and()
,logical_xor()
, andlogical_not()
; Instead, users should rely directly on the corresponding operators (+
,-
,*
,/
,%
,>
,>=
,<
,<=
,==
,!=
,&
,^
, and~
).identity()
andreciprocal()
; users can implement these trivially.select()
; removed in favor of usingSIMD.select()
directly.is_even()
andis_odd()
; these can be trivially implemented using bitwise&
with1
.roundeven()
; the newSIMD.roundeven()
method now provides the identical functionality.div_ceil()
; use the newceildiv()
function.rotate_left()
androtate_right()
; the same functionality is available in the builtinSIMD.rotate_{left,right}()
methods forSIMD
types, and thebit.rotate_bits_{left,right})()
methods forInt
.- An overload of
math.pow()
taking an integer parameter exponent. align_down_residual()
; it can be trivially implemented usingalign_down()
.all_true()
,any_true()
, andnone_true()
; useSIMD.reduce_and()
andSIMD.reduce_or()
directly.reduce_bit_count()
; use the newSIMD.reduce_bit_count()
directly.rint()
andnearbyint()
; useround()
orSIMD.roundeven()
as appropriate.
-
The
EvaluationMethod
has been removed frommath.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 ofmath.polynomial.polynomial_evaluate()
is unchanged (Horner's method). -
The
math.bit.select()
andmath.bit.bit_and()
functions have been removed. The same functionality is available in the builtinSIMD.select
andSIMD.__and__()
methods, respectively. -
The
math.limit
module has been removed. The same functionality is available as follows:math.limit.inf()
: useutils.numerics.max_or_inf()
math.limit.neginf()
: useutils.numerics.min_or_neg_inf()
math.limit.max_finite()
: useutils.numerics.max_finite()
math.limit.min_finite()
: useutils.numerics.min_finite()
-
The
tensor.random
module has been removed. The same functionality is now accessible via theTensor.rand()
andTensor.randn()
static methods. -
The builtin
SIMD
struct no longer conforms toIndexer
; users must explicitly castScalar
values usingint
.
🛠️ Fixed
- #1837 Fix self-referential variant crashing the compiler.
- #2363 Fix LSP crashing on simple trait definitions.
- #1787 Fix error when using
//
onFloatLiteral
in alias expression. - Made several improvements to dictionary performance. Dicts with integer keys are most heavily affected, but large dicts and dicts with large values will also see large improvements.
- #2692 Fix
assert_raises
to include calling location.
Special thanks
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
v24.3 (2024-05-02)
✨ Highlights
-
AnyPointer
was renamed toUnsafePointer
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()
, andmove_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 aReference
withUnsafePointer(someRef)
and can convert to a reference withyourPointer[]
. 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 consistentbitcast()
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 ofprint
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]()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
): ...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]():
passfn variadic_param_after_default[e: Int, f: Int = 2, *params: Int]():
passNote that variadic keyword parameters are not supported yet.
For more information, see Variadic arguments in the Mojo Manual.
-
-
The
mojo build
andmojo run
commands now support a-g
option. This shorter alias is equivalent to writing--debug-level full
. This option is also available in themojo 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.
Language changes
-
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 thanself
(for a getter) orself
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 errorstruct 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 193from 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 193This 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>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>
Standard library changes
⭐️ New
-
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 theList
. (@whym1here, fixes #2134) -
A new constructor
List(ptr, size, capacity)
to to avoid needing to do a deep copy of an existing contiguous memory allocation when constructing a newList
. (@StandinKP, fixes #2170)
-
-
Dict
now has aupdate()
method to update keys/values from anotherDict
. (@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
, andSet
all conform to theBoolable
trait. The collections evaluate toTrue
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.")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
, andDict
now support iterating in reverse.var numbers = List(1, 2, 3, 4, 5)
for number in reversed(numbers):
print(number)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 anOptional
withNone
. For example:var opt = Optional(1)
if opt is not None:
print(opt.value()[])var opt = Optional(1)
if opt is not None:
print(opt.value()[]) -
Tuple
now works with memory-only element types likeString
and allows you to directly index into it with a parameter expression. This means you can now simply usex = tup[1]
like Python instead ofx = tup.get[1, Int]()
. You can also assign into tuple elements now as well withtup[1] = x
.var tuple = ("Green", 9.3)
var name = tuple[0]
var value = tuple[1]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 ordinaryfor
loop. -
The
Reference
type has several changes, including:-
It has moved to the
memory.reference
module instead ofmemory.unsafe
. -
Reference
now has anunsafe_bitcast()
method, similar to the pointer types. -
Several unsafe methods were removed, including
offset()
,destroy_element_unsafe()
andemplace_ref_unsafe()
. This is becauseReference
is a safe type—useUnsafePointer
to do unsafe operations.
-
-
Bool
can now be implicitly converted from any type conforming to theBoolable
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())@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())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__():
...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 theKeyElement
trait, meaning that it can be used as key type forDict
. 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'}`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 awhence
argument that defaults toos.SEEK_SET
to seek from the beginning of the file. You can now set toos.SEEK_CUR
to offset by the currentFileHandle
seek position:var f = open("/tmp/example.txt")
# Skip 32 bytes
f.seek(os.SEEK_CUR, 32)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)# Start from 32 bytes before the end of the file
f.seek(os.SEEK_END, -32) -
FileHandle.read()
can now read straight into aDTypePointer
: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]())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 anexit()
function that would exit a Mojo program with the specified error code.from sys import exit
exit(0)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 a2x2
tensor initialized with all zeros. This provides an easy way to fill in the data of a tensor. -
String
now hasremoveprefix()
andremovesuffix()
methods. (@gabrieldemarmiesse) -
The
ord
andchr
functions have been improved to accept any Unicode character. (@mzaks, contributes towards #1616) -
atol()
now handles whitespace. Theatol()
function is used internally byString.__int__()
, soint(String( " 10 "))
now returns10
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 implementsgather()
for gathering aSIMD
vector from offsets of a current pointer. Similarly, support forscatter()
was added to scatter aSIMD
vector into offsets of the current pointer. (@leandrolcampos) -
The
len()
function now handles arange()
specified with a negative end value, so that things likelen(range(-1))
work correctly. (@soraros) -
debug_assert()
now prints its location (filename, line, and column where it was called) in its error message. Similarly, theassert
helpers in thetesting
module now include location information in their messages. -
The
testing.assert_equal[SIMD]()
function now raises if any of the elements mismatch in the twoSIMD
arguments being compared. (@gabrieldemarmiesse) -
The
testing.assert_almost_equal()
andmath.isclose()
functions now have anequal_nan
flag. When set toTrue
, 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 likeInt64
) 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])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()
andos.unlink()
for deleting files. (@artemiogr97, fixes #2306)
🦋 Changed
-
The
parallel_memcpy()
function has moved from thebuffer
package to thealgorithm
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()[]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 ofError
toDTypePointer[DType.uint8]
. (@gabrieldemarmiesse, contributes towards #2317) -
Continued transition to
UnsafePointer
from the legacyPointer
type in various standard library APIs and internals. (@gabrieldemarmiesse)
Tooling changes
-
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
ormojo 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.
Other changes
Low-level language changes
-
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}`,
]()_ = __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 MLIRDictionaryAttr
value.
❌ Removed
-
Support for "register only" variadic packs has been removed. Instead of
AnyRegType
, please upgrade your code toAnyType
in examples like this:fn your_function[*Types: AnyRegType](*args: *Ts): ...
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. UseList.pop()
instead which defaults to popping the last element in the list. -
SIMD.to_int(value)
has been removed. Useint(value)
instead. -
The
__get_lvalue_as_address(x)
magic function has been removed. To get a reference to a value useReference(x)
and if you need an unsafe pointer, you can useUnsafePointer.address_of(x)
.
🛠️ Fixed
-
#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 bymojo 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.
v24.2.1 (2024-04-11)
This release doesn't include any changes to Mojo.
v24.2 (2024-03-28)
🔥 Legendary
-
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 toStringable
, and is usable with thestr()
built-in function.@value
struct Foo:
fn __str__(self) -> String:
return "foo!"
fn main():
print(str(Foo())) # prints 'foo!'@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): ...@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()from python import Python
def main():
plt = Python.import_module("matplotlib.pyplot")
plt.plot((5, 10), (10, 15), color="red")
plt.show()
Language changes
⭐️ New
-
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)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.
🦋 Changed or removed
-
let
declarations now produce a compile time error instead of a warning, our next step in removing let declarations. The compiler still recognizes thelet
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
andfn
declarations, instead of completely disabling the warning indef
s. It never warns about unusedobject
orPythonObject
values, tying the warning to these types instead of the kind of function they are unused in. This will help catch API usage bugs indef
s and make imported Python APIs more ergonomic infn
s. -
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 allowedvar t = Int # dynamic type values not allowed
struct SomeType: ...
takes_type(SomeType) # dynamic type values not allowedWe 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 🔥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, *_]# 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.
Standard library changes
⭐️ New
-
DynamicVector
has been renamed toList
, and has moved from thecollections.vector
module to thecollections.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)
var numbers = List[Int](1, 2, 3)
-
List
andInlinedFixedVector
types now support negative indexing. This means that you can writevec[-1]
which is equivalent tovec[len(vec)-1]
. -
List.push_back()
has been removed. Please use theappend()
function instead.
-
-
The
print()
function now takessep
andend
keyword arguments. This means that you can write:print("Hello", "Mojo", sep=", ", end="!!!\n") # prints Hello, Mojo!!!
print("Hello", "Mojo", sep=", ", end="!!!\n") # prints Hello, Mojo!!!
sep
defaults to the empty string andend
defaults to "\n".Also, the
print_no_newline()
function has been removed. Please useprint(end="")
instead. -
The
FloatLiteral
type is now an infinite-precision nonmaterializable type. This means you can do compile-time calculations usingFloatLiteral
without rounding errors. When materialized at runtime, aFloatLiteral
value is converted to aFloat64
.# third is an infinite-precision FloatLiteral value
alias third = 1.0 / 3.0
# t is a Float64
var t = third# 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 callint("123")
to get the integer123
. If the integer cannot be parsed from the string, then an error is raised. -
The
Tensor
type now hasargmax()
andargmin()
functions to compute the position of the max or min value. Note: this should return aTensor[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 toOptional
. -
The
ulp()
function has been added to themath
module. This allows you to get the units of least precision (or units of last place) of a floating point value.
🦋 Changed
-
The
simd_load()
,simd_store()
,aligned_simd_load()
, andaligned_simd_store()
methods onDTypePointer
,Buffer
, andNDBuffer
have been merged into a more expressive set ofload()
andstore()
methods with keyword-onlywidth
andalignment
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)# 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 toStaticTuple[type, size]
for consistency withSIMD
and similar collection types. -
The signature of the
elementwise()
function has been changed. The new order is isfunction
,simd_width
, and thenrank
. As a result, the rank parameter can now be inferred and one can callelementwise()
without it:elementwise[func, simd_width](shape)
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 borrowsself
rather than requiringinout
, allowing code like:for value in my_dict.values():
...for value in my_dict.values():
...
🚚 Moved
-
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 thememory
package into a newbuffer
package.from buffer import Buffer, NDBuffer
from buffer import Buffer, NDBuffer
-
utils.list
, including theDim
andDimList
types, has moved to thebuffer
package.from buffer import Dim, DimList
from buffer import Dim, DimList
-
The
parallel_memcpy()
function has moved from thememory
package into thebuffer
package.from buffer import parallel_memcpy
from buffer import parallel_memcpy
-
The
rand()
andrandn()
functions from therandom
package that return aTensor
have moved to thetensor
package. Note that the overloads that write to aDTypePointer
remain in therandom
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_dtfrom tensor import rand
from random import rand as rand_dt -
The
trap()
function has been renamed toabort()
. It also has moved from thedebug
module to theos
module.from os import abort
from os import abort
-
The
isinf()
andisfinite()
methods have been moved frommath.limits
to themath
module.from math import ininf, isfinite
from math import ininf, isfinite
-
Tooling changes
⭐️ New
-
Docstring code blocks can now use
%#
to hide lines of code from documentation generation.For example:
var value = 5
%# print(value)var value = 5
%# print(value)Will generate documentation of the form:
var value = 5
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 themojo.lsp.includeDirs
setting in the VS Code extension.
Other changes
❌ Removed
-
The
__get_address_as_lvalue
magic function has been removed. You can now get an LValue from aPointer
orReference
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)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 tomemcpy
of the formmemcpy[Dtype.xyz](...)
will no longer work and the user would have to change the code tomemcpy(...)
. -
The
memcpy()
overload that worked onBuffer
types has been removed in favor of just overloads forPointer
andDTypePointer
:# Doesn't work
memcpy(destBuffer, srcBuffer, count)
# Works
memcpy(destBuffer.data, srcBuffer.data, count)# 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 frommath.limit
. These functions were only used by the SIMD type. -
As mentioned previously, the
print_no_newline()
function has been removed. Please useprint(end="")
instead.
🛠️ Fixed
- #1362 - Parameter inference now recursively matches function types.
- #951 - Functions that were
both
async
and@always_inline
incorrectly errored. - #1858 - Trait with parametric methods regression.
- #1892 - Forbid unsupported decorators on traits.
- #1735 - Trait-typed values are incorrectly considered equal.
- #1909 - Crash due to nested import in unreachable block.
- #1921 - Parser crashes binding Reference to lvalue with subtype lifetime.
- #1945 -
Optional[T].or_else()
should returnT
instead ofOptional[T]
. - #1940 - Constrain
math.copysign
to floating point or integral types. - #1838 - Variadic
print
does not work when specifyingend=""
- #1826 - The
SIMD.reduce
methods correctly handle edge cases wheresize_out >= size
.
v24.1.1 (2024-03-18)
This release includes installer improvements and enhanced error reporting for installation issues. Otherwise it is functionally identical to Mojo 24.1.
v24.1 (2024-02-29)
🔥 Legendary
-
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 version24.1
. -
Mojo debugging support is here! The Mojo VS Code extension includes debugger support. For details, see Debugging in the Mojo Manual.
⭐️ New
-
We now have a
Set
type in our collections!Set
is backed by aDict
, so it has fast add, remove, andin
checks, and requires member elements to conform to theKeyElement
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)) # 1from 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 fory.__contains__(x)
as well asx 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'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 34fn 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 34Note 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): ...
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 theend
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 stringfn foo(arg: Int):
"""""" # Unexpected empty documentation stringApplying the fixit from above will generate:
fn foo(arg: Int):
"""[summary].
Args:
arg: [description].
"""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]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]()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[])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 withinout 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@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.bThis 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@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 toSlice
, and aslice
function has been introduced. This makes Mojo closer to Python and makes theSlice
type follow the naming conventions of other types likeInt
. -
"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: ...@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
likeyc[42:3.14:"🔥"]
and the three values are passed to theUnusualSlice
constructor. -
The
__refitem__()
accessor method may now return aReference
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 theIntable
trait as a hexadecimal string. -
PythonObject
now implements__is__
and__isnot__
so that you can use expressions of the formx is y
andx is not y
withPythonObject
. -
PythonObject
now conforms to theSizedRaising
trait. This means the built-inlen()
function now works onPythonObject
. -
The
os
package now contains thestat()
andlstat()
functions. -
A new
os.path
package now allows you to query properties on paths. -
The
os
package now has aPathLike
trait. A struct conforms to thePathLike
trait by implementing the__fspath__()
function. -
The
pathlib.Path
now has functions to query properties of the path. -
The
listdir()
method now exists onpathlib.Path
and also exists in theos
module to work onPathLike
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])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":
...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
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
, andCollectionElement
. -
A new magic
__lifetime_of(expr)
call will yield the lifetime of a memory value. We hope and expect that this will eventually be replaced byReference(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 zfn my_function(x: Int, y: __type_of(x)) -> Int:
let z: __type_of(x) = y
return z
🦋 Changed
-
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 avar
declaration so your code won't break. We emit a warning about this, but please switch your code to usingvar
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 = 9fn 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 parametersfn autoparameterized(x: SIMD):
pass
autoparameterized[DType.int32, 1](3) # error: too many parameters -
vectorize_unroll
has been removed, andvectorize
now has a parameter namedunroll_factor
with a default value of 1. Increasingunroll_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 closurefunc
moved to the first parameter:vectorize[func, width, unroll_factor = 1](size)
vectorize[func, width, size, unroll_factor = 1]()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 closurefunc
moved to the first parameter:unroll[func, unroll_count]()
unroll[func, unroll_count]()
-
The signature of the
NDBuffer
andBuffer
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]
NDBuffer[DType.float32, 3]
is equivalent to
NDBuffer[DType.float32, 3, DimList.create_unknown[3]()]
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)]
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 fromcollections.vector
. -
The
DynamicVector(capacity: Int)
constructor has been changed to takecapacity
as a keyword-only argument to prevent implicit conversion fromInt
. -
Variant.get[T]()
now returns aReference
to the value rather than a copy. -
The
String
methodstolower()
andtoupper()
have been renamed tostr.lower()
andstr.upper()
. -
The
ref
andmutref
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 theReference
type will provide a good experience without dedicated sugar.
🛠️ Fixed
- #435 Structs with Self type don't always work.
- #1540 Crash in register_passable self referencing struct.
- #1664 - Improve error
message when
StaticTuple
is constructed with a negative size for the number of elements. - #1679 - crash on SIMD of zero elements.
- Various crashes on invalid code: #1230, #1699, #1708
- #1223 - Crash when parametric function is passed as (runtime) argument. The parser now errors out instead.
- #1530 - Crash during diagnostic emission for parameter deduction failure.
- #1538 and #1607 - Crash when returning type value instead of instance of expected type. This is a common mistake and the error now includes a hint to point users to the problem.
- #1613 - Wrong type name in
error for incorrect
self
argument type in trait method declaration. - #1670 - Crash on implicit conversion in a global variable declaration.
- #1741 - Mojo documentation
generation doesn't show
inout
/owned
on variadic arguments. - #1621 - VS Code does not
highlight
raises
andcapturing
in functional type expressions. - #1617 - VS Code does not
highlight
fn
in specific contexts. - #1740 - LSP shows unrelated info when hovering over a struct.
- #1238 - File shadows Mojo package path.
- #1429 - Crash when using nested import statement.
- #1322 - Crash when missing types in variadic argument.
- #1314 - Typecheck error when binding alias to parametric function with default argument.
- #1248 - Crash when importing from file the same name as another file in the search path.
- #1354 - Crash when importing from local package.
- #1488 - Crash when setting generic element field.
- #1476 - Crash in interpreter when calling functions in parameter context.
- #1537 - Crash when copying parameter value.
- #1546 - Modify nested vector element crashes parser.
- #1558 - Invalid import causes parser to crash.
- #1562 - Crash when calling parametric type member function.
- #1577 - Crash when using unresolved package as a variable.
- #1579 - Member access into type instances causes a crash.
- #1602 - Interpreter failure when constructing strings at compile time.
- #1696 - Fixed an issue that caused syntax highlighting to occasionally fail.
- #1549 - Fixed an issue when
the shift amount is out of range in
SIMD.shift_left
andSIMD.shift_right
.
v0.7.0 (2024-01-25)
⭐️ New
-
A new Mojo-native dictionary type,
Dict
for storing key-value pairs.Dict
stores values that conform to theCollectionElement
trait. Keys need to conform to the newKeyElement
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 aStringKey
type and uses it to create a dictionary that maps strings toInt
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
fn main() raises:
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 1from 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
fn main() raises:
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 1We 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 invokingmojo
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 includesnum_physical_cores()
,num_logical_cores()
, andnum_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 aVariadicListMem
.(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 supportinout
andowned
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 worldfn 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 aReference
(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"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))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. TheReference
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.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 MojoPointer
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 namedmemory.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 print5
, not2
.fn foo(x: Int):
var z = x
@__copy_capture(z)
@parameter
fn formatter() -> Int:
return z
z = 2
print(formatter())
fn main():
foo(5)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))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))
❌ Removed
-
The
__takeinit__
special constructor form has been removed from the language. This "non-destructive move" operation was previously wired into thex^
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()
, andsearch()
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 toDynamicVector
which works on both register passable and memory types. -
The
UnsafeFixedVector
inutils.vector
has been removed. We recommend using eitherDynamicVector
orInlinedFixedVector
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()@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()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!
🦋 Changed
-
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
andparallelize
. They are always denoted by@parameter
and have typefn() capturing -> T
(whereT
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_functionfn 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_functionThe 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 thepython
package has been moved to be an internal module, i.e,_cpython
. -
AnyType
andDestructable
have been unified into a single trait,AnyType
. Every nominal type (i.e. all structs) now automatically conform toAnyType
. -
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 themojo 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 firstimport
-ed. As a result, Mojo packages are smaller and more portable. -
The
simd_width
anddtype
parameters ofpolynomial_evaluate
have been switched. Based on the request in #1587, thepolynomial_evaluate
function has also been extended so that thecoefficients
parameter can take either a either aStaticTuple
or aVariadicList
. -
As a tiny step towards removing
let
declarations, this release removes the warning:'var' was never mutated, consider switching to a 'let'
.
🛠️ Fixed
- #1595 - Improve error message
when trying to materialize
IntLiteral
in runtime code. - Raising an error from the initializer of a memory-only type now works
correctly in the presence of complex control flow. Previously Mojo could run
the destructor on
self
before it was initialized when exiting with an error. - #1096 - Improve warning
messages for dead code in conditionals like
or
expressions. - #1419 - Fix assertion failure with uninitialized lattice values.
- #1402 - Fix movable trait not
detected on recursive struct implemented with
AnyPointer
. - #1399 - Fix parser crash when a parameter type in a struct that implements a trait is misspelled.
- #1152 - Allow mutable
self
argument when overloading operators using dunder methods. - #1493 - Fix crash in
DynamicVector
copy constructor in certain situations. - #1316 - The
benchmark.keep
function now properly handles vector types. - #1505 - The
simd.shuffle
operation now works on 64 element permutations. - #1355 - Fix
String.find()
returning wrong value when starting index is non-zero. - #1367 - Fix
String.replace()
returning incorrect results for multi-character search strings. - #1535 - Invalid error
field 'w.x.y' destroyed out of the middle of a value, preventing the overall value from being destroyed
. - #1475 - Assertion failure in nested loop.
- #1591 - Assertion failure
when using
AnyType
struct member. - #1503 - Rename the mojo build
of LLDB to
mojo-lldb
, to prevent name collisions with the system's LLDB. - #1542 -
@unroll
does not accept alias as unroll factor. - #1443 - Compiler crash on variadic list of traits.
- #1604 - Variable of trivial type not destroyed by transferring ownership.
- #1341 - Segmentation fault when passing closures around.
- #217 - Closure state is stack allocated.
v0.6.1 (2023-12-18)
⭐️ New
-
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 directorydir
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 theMovable
andCopyable
built-in traits. -
String
now has newtoupper()
andtolower()
methods analogous, respectively, to Python'sstr.toupper()
andstr.tolower()
. -
Added a
hash()
built-in function andHashable
trait for types implementing the__hash__()
method. Future releases will addHashable
support to Standard Library types. In the meantime, thehash
module includes a version of thehash()
function that works on arbitrary byte strings. To generate hashes forSIMD
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)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 includeBool
,StringLiteral
,DynamicVector
,Tensor
,TensorShape
, andTensorSpec
.
🦋 Changed
-
utils.vector
has been moved to a newcollections
package to make space for new collections. This means that if you had previous code that didfrom utils.vector import DynamicVector
, it now needs to befrom 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.
🛠️ Fixed
-
#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
.
v0.6.0 (2023-12-04)
🔥 Legendary
-
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): ...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)