v0.26.2 (2026-03-19)

✨ Highlights

• Official Modular AI agent skills. Modular has released official AI agent skills for working with MAX and Mojo. The four skills—new-modular-project, mojo-syntax, mojo-gpu-fundamentals, and mojo-python-interop—help AI coding agents create new projects with the right tooling, generate correct modern Mojo syntax, follow GPU programming best practices, and handle Python-Mojo interop. The skills follow the open Agent Skills Standard and work with Claude Code and other compatible agents. Install them with npx skills add modular/skills.

• Conditional trait conformances. Structs can now declare trait conformances that apply only when type parameters satisfy certain conditions, using where clauses in the conformance list. Nine standard library types—including List, Dict, Set, and Optional—now use this feature to enforce trait requirements at compile time. See Language enhancements and Conditional conformances.

• def/fn unification. def is now Mojo's standard function declaration keyword. def functions no longer implicitly raise and now have the same semantics as fn: non-raising by default, with explicit raises for functions that can throw. fn is deprecated and will be removed in a future release. See Language enhancements.

• T-strings. Mojo now supports template strings with the t"..." prefix. T-strings produce a TString value that captures both the static format string and runtime arguments, enabling structured string processing without immediate allocation. See Language enhancements.

• comptime if and comptime for. The new comptime if and comptime for syntax replaces the legacy @parameter if and @parameter for decorator forms for compile-time conditionals and loops. Both syntaxes are accepted in this release; the @parameter forms will be deprecated soon. See Language enhancements.

• assert statement. Mojo now supports a standalone assert statement, similar to Python's assert. It checks a condition at runtime and aborts if the condition is false, with an optional message. Under the hood, assert desugars to debug_assert() and respects the -D ASSERT flag. See Language enhancements.

• @align(N) decorator. Structs can now specify minimum alignment with @align(N), similar to C++ alignas and Rust #[repr(align(N))]. The alignment value can be a struct parameter, enabling generic cache-aligned and hardware-aligned types. See Language enhancements.

• Implicit Int to SIMD conversions deprecated. Implicit conversions from Int to SIMD scalar types like Int8 or Float32 are now deprecated. Code relying on these conversions should use explicit constructors instead. The mojo build --experimental-fixit command can assist with migration. See Math and numeric types.

• Init unification. The __moveinit__() and __copyinit__() methods are now renamed to __init__() with keyword-only take and copy arguments, respectively. The legacy names are still accepted but should be migrated to the modern form. See Init unification.

• Stringable and Representable deprecated. These traits are replaced by the unified Writable trait, which provides default implementations. Most standard library types have already had their Stringable and Representable conformances removed. See String and text.

• UTF-8 safety improvements. String and StringSlice subscripting now panics when an index falls in the middle of a multi-byte codepoint, and String.resize() panics on operations that would produce invalid UTF-8. Byte-position subscripting now returns an entire Unicode codepoint instead of a single byte. See String and text.

• trait no longer inherits ImplicitlyDestructible. Trait declarations no longer automatically conform to ImplicitlyDestructible; traits that need it must now opt in explicitly. This continues v0.26.1's work on explicitly-destroyed types and encourages the ecosystem to support linear types by default. See Other changes.

Documentation

• Added a new Mojo tips for Python devs page to the Mojo Manual, covering key differences Python developers encounter when learning Mojo. Topics include variable declarations with var, type annotations, integer vs. floating-point division, implicit conversions, and other common gotchas. If you're coming from Python, this page helps you avoid surprises and write idiomatic Mojo faster.

• Added a new Instance initialization deep dive page to the Mojo Manual. This page explains the difference between logical and fieldwise initialization, how to write __init__ constructors that satisfy the compiler's field-by-field initialization requirements, and how copy and move constructors fit into the initialization model. Essential reading for anyone working with non-trivial struct types.

• Added a new Generics page to the Mojo Manual with worked examples of conditional trait conformance. The page shows how to use where clauses to declare that a generic type conforms to a trait only when its type parameters meet certain conditions, such as making a container Equatable only when its element type is.

• Restructured and expanded the metaprogramming section of the Mojo Manual. This includes a new introduction page, which provides an overview of Mojo's compile-time metaprogramming model, and new pages on compile-time evaluation, reflection, and materialization, as well as the previously-mentioned page on generics. Together these changes cover several previously undocumented topics and provide a smoother learning path from basic parameters to advanced metaprogramming techniques.

• Updated the Jupyter Notebooks page with Apple Silicon GPU examples and setup instructions, so macOS users with M-series chips can run GPU-accelerated Mojo code in notebooks without needing an external GPU.

Language enhancements

• def is now Mojo's standard function declaration keyword. def functions no longer implicitly raise and now have the same semantics as fn: they are non-raising by default, accept a raises specifier, and support typed errors. fn is now deprecated and will be removed in a future release. We recommend switching all fn declarations to def.

  # Previously
  def foo():                        # Implicitly raised Error.
  fn bar():                         # Did not raise.
  fn baz() raises:                  # Explicitly raised Error.
  fn qux() raises EmptyDictError:   # Raised a typed error.
  
  # Now
  def foo():                        # Does not raise.
  def bar() raises:                 # Explicitly raises Error.
  def baz() raises EmptyDictError:  # Raises a typed error.
  fn qux():                         # Deprecated: use 'def' instead.
  fn qux() raises:                  # Deprecated: use 'def' instead.
  fn qux() raises EmptyDictError:   # Deprecated: use 'def' instead.

  This change clarifies function contracts by making error handling explicit: a def without raises guarantees that errors are handled locally or cannot occur, and the compiler enforces this no-throw guarantee.

• Mojo now supports conditional trait conformances on struct declarations. A struct can declare that it conforms to a trait only when its type parameters satisfy certain conditions, using where clauses in the conformance list. The where clause accepts any Bool-typed parameter expression. For example, List now uses this to conditionally conform to Equatable and Writable only when its element type does:

  struct List[T: Movable](
      Copyable,
      Equatable where conforms_to(T, Equatable),
      Movable,
      Writable where conforms_to(T, Writable),
  ):
      ...

  Here is a small self-contained example:

  @fieldwise_init
  struct Wrapper[T: Copyable & ImplicitlyDestructible](
      Writable where conforms_to(T, Writable),
  ):
      var value: Self.T
  
  @fieldwise_init
  struct NotWritable(Copyable, ImplicitlyDestructible):
      var data: Int
  
  def main():
      var w = Wrapper[Int](42)
      print(w)  # OK — Int is Writable. Prints: Wrapper[Int](value=42)
  
      var w2 = Wrapper[NotWritable](NotWritable(10))  # OK to construct
      print(w2)  # errors at parse time

  Current limitations: Conditional conformance to RegisterPassable, TrivialRegisterPassable, and ImplicitlyDestructible is not yet supported.

• Mojo now supports t-strings (template strings) for building structured string templates with interpolated expressions. T-strings use the t"..." prefix and produce a TString value that captures both the static format string and any runtime arguments, rather than immediately producing a String:

  def main():
      var x = 10
      var y = 20
      print(t"{x} + {y} = {x + y}")  # prints: 10 + 20 = 30

  Use {{ and }} to include literal braces in the output:

  print(t"Use {{braces}} like this")  # prints: Use {braces} like this

• Mojo now supports comptime if and comptime for as the preferred syntax for compile-time conditional and loop constructs, replacing the legacy @parameter if and @parameter for decorator forms:

  # Old syntax (still accepted, deprecated in a future release)
  @parameter
  if some_condition:
      ...
  
  @parameter
  for i in range(10):
      ...
  
  # New syntax
  comptime if some_condition:
      ...
  
  comptime for i in range(10):
      ...

  Both syntaxes are accepted in this release. The @parameter forms will be deprecated soon, and the parser will generate a warning and a fixit suggestion to migrate to the new syntax.

• Mojo now supports a standalone assert statement, similar to Python's assert. It checks a condition at runtime and aborts the program if the condition is false:

  assert x > 0, "x must be positive"
  assert len(items) != 0

  The condition must be a Bool expression and the optional message can be any Writable expression (StringLiteral, String, Int, etc.). Under the hood, assert desugars to a call to debug_assert(), so it respects the existing -D ASSERT flag: assertions are active when compiled with -D ASSERT=all and are no-ops otherwise.

• Mojo now supports the @align(N) decorator to specify minimum alignment for structs, similar to C++'s alignas and Rust's #[repr(align(N))]. The value N must be a positive power of 2 and specifies the minimum alignment in bytes. The actual alignment is max(N, natural_alignment)—you cannot use @align to reduce alignment below the struct's natural alignment. For example, @align(1) on a struct containing an Int (8-byte aligned) will emit a warning and the struct will remain 8-byte aligned.

  from sys import align_of
  
  @align(64)
  struct CacheAligned:
      var data: Int
  
  def main():
      print(align_of[CacheAligned]())  # Prints 64

  Both stack and heap allocations respect @align.

  The alignment value can also be a struct parameter, enabling generic aligned types:

  @align(Self.alignment)
  struct AlignedBuffer[alignment: Int]:
      var data: Int
  
  def main():
      print(align_of[AlignedBuffer[64]]())   # Prints 64
      print(align_of[AlignedBuffer[128]]())  # Prints 128

• Mojo now supports specifying a default value for an inferred parameter, making it easier to create a partially bound type:

  struct Pointer[mut = False, // o: Origin[mut]] : pass
  
  # Default to immutable pointer
  comptime ImmPointer = Pointer[_]
  # Explicitly set to mutable pointer
  comptime mutPointer = Pointer[mut = True, _]
  # Inferred mutability from `SomeOrigin()`
  comptime InferredPointer = Pointer[SomeOrigin()]
  # Parametric mutability pointer.
  comptime ParametricPointer = Pointer[...]

• Mojo now enforces more explicit parameter binding rules:

  • [] is mandatory to make type more concrete:

    struct SomeStruct[a : Int = 1]:
      pass
    
    # SS1 is a parametric type
    comptime SS1 = SomeStruct
    
    # SS2 a concrete type alias of `SomeStruct[1]
    comptime SS2 = SomeStruct[]
    

  • When [] is used, it must produce a concrete type unless _/... is used to unbind a specific/multiple missing parameters.

    struct SomeStruct[a : Int, b: Int, c: Int = 2]:
      pass
    
    # Error: can not infer `b`, since `[]` must produce a concrete type, without `_`/`...``
    comptime SS1 = SomeStruct[1]
    
    # This is a concrete type alias of `SomeStruct[1, 1, 2]`
    comptime SS2 = SomeStruct[1, 1]
    
    # Using `...` defers binding of b and c, and produces `SomeStruct[1, ?, ?]` (preserving possible defaults)
    comptime SS3 = SomeStruct[1, ...]
    
    # Even though SS3 unbinds `c`, Mojo keeps track of the fact that there is a default value for c:
    # This install b (using 1) and c (using default value), and produce `SomeStruct[1, 1, 2]`
    comptime SS4 = SS3[1]
    
    # This installs the default and is identical to `SomeStruct[1, ?, 2]`
    comptime SS5 = SomeStruct[1, _]
    
    # This unbind the default explicitly and is identical to `SomeStruct[1, ?, ?]`
    comptime SS6 = SomeStruct[1, _, _]
    
    
    # The following two are equivalent:
    comptime SS7 = SomeStruct
    comptime SS8 = SomeStruct[...]
    

• Mojo now supports more flexible default arguments and parameters, which can mismatch on declared type when their types are parametric. This allows inferring parameters from these when they are used as a default value, for example:

    def take_string_slice[o: ImmOrigin](str: StringSlice[o] = ""): ...
    def use_it():
      take_string_slice() # Ok, defaults to empty string, inferring "o".
      # Explicit calls also work of course.
      take_string_slice(StaticString("hello"))
  
    # Default value is checked for validity at the call site.
    def defaultArgumentBadType2[T: AnyType](a: T = 1.0): pass
    def callDefaultArgumentBadType2():
        # Ok!
        defaultArgumentBadType2[Float64]()
        # error: value passed to 'a' cannot be converted from 'FloatLiteral[1]' to 'Int'
        defaultArgumentBadType2[Int]()

• Mojo now allows move constructors to take their "take" argument as either deinit or var. deinit should be generally preferred, but var can be useful in unusual cases where you want C++-like behavior where the destructor still runs on the value after the move constructor is done with it.

  def __init__(out self, *, var take: Self):
    self.data = munge(take.data)
    # take.__del__() runs here.

Language changes

Init unification

• As part of "init unification", the __moveinit__() and __copyinit__() methods are now renamed to fn __init__(out self, *, take: Self) and fn __init__(out self, *, copy: Self) respectively. Mojo now accepts these names for initializers, but also supports the legacy __moveinit__() and __copyinit__() names as well (for now). However, the argument name for these legacy methods must now be named take and copy respectively. Please move to the more modern __init__ names when possible.

• As part of init unification, the __moveinit__is_trivial and __copyinit__is_trivial members of Movable and Copyable have been renamed to __move_ctor_is_trivial and __copy_ctor_is_trivial respectively.

Deprecations

• @register_passable("trivial") is now deprecated. Conform to the TrivialRegisterPassable trait instead. The decorator will be removed after the next release.

• @register_passable is now deprecated. Conform to the RegisterPassable trait instead. The decorator will be removed after the next release.

• LegacyUnsafePointer is now deprecated. Use UnsafePointer instead. Check the docstrings in unsafe_pointer.mojo for guidance on migration. LegacyUnsafePointer will be removed after the next release.

comptime assert

• Unstable __comptime_assert syntax is now finalized as comptime assert. A deprecation warning is emitted with a fixit for the old syntax.

• comptime assert no longer errors on always-false conditions. The assertion will only trigger if its parent scope is concretized.

• A statically False comptime assert now ends a scope. Any code following it in the same scope is now a warning, and can be removed.

Other changes

• **_ and *_ are no longer supported in parameter binding lists. Use a more concise ... to unbind any unspecified parameter explicitly.

• Homogeneous variadic parameters are now passed with the VariadicParamList type (formerly known as VariadicList) and arguments are now consistently passed with VariadicList (formerly VariadicListMem) instead of trivial types being passed directly.

• Slice literals in subscripts have changed to be more similar to collection literals. They now pass an empty tuple as a required __slice_literal__ keyword argument to disambiguate slices. If you have defined your own range types, please add a __slice_literal__: () = () argument to their constructors.

• trait declarations no longer automatically inherit from ImplicitlyDestructible. struct declarations are not changed, and continue to inherit from ImplicitlyDestructible.

  Previously, the @explicit_destroy annotation was required to opt-out of ImplicitlyDestructible conformance. Now, if a trait's usage depends on implicit destructibility, it must opt-in explicitly:

  # Before
  trait Foo:
      ...
  
  # After:
  trait Foo(ImplicitlyDestructible):
      ...

  Conversely, if a trait wanted to support non-implicitly-destructible types, it no longer needs to be annotated with @explicit_destroy:

  # Before
  @explicit_destroy
  trait Foo:
      ...
  
  # After
  trait Foo:
      ...

  Making struct continue to inherit from ImplicitlyDestructible and not trait is intended to balance usability and familiarity in the common case, with the need to foster broad Mojo ecosystem support for explicitly destroyed types.

  It's not a problem if the majority of struct types are ImplicitlyDestructible in practice. However, if many ecosystem libraries are written with unnecessary ImplicitlyDestructible bounds, that would hamper the usability of any individual struct type that opts-in to being explicitly destroyed.

  Libraries with generic algorithms and types should be written to accommodate linear types. Making ImplicitlyDestructible opt-in for traits encourages a default stance of support, with specific types and functions only opting-in to the narrower ImplicitlyDestructible requirement if they truly need it.

  The majority of generic algorithms that take their inputs by reference should not be affected.

• Re-exported symbols from a package's __init__.mojo are no longer shadowed by a submodule of the same name. For example, if pkg/foo.mojo defines fn foo and pkg/__init__.mojo does from .foo import foo, then from pkg import foo and from pkg import * now correctly resolve to the function rather than the module.

• is_compile_time() has been renamed to __is_run_in_comptime_interpreter, which is now a keyword rather than a function call. It provides a mechanism for supporting different code execution paths in the comptime interpreter versus runtime-generated code. This value cannot be used as a constant in any comptime expressions because it is always evaluated as True for comptime expressions. Use the check as a condition for runtime if. The compiler now warns if it is used as a condition for comptime if.

• Mojo supports indexing with subscripts and names using the standard Python __getitem__() and __getattr__() methods. Previously it used a heuristic to determine whether a __get*__ method was operated with dynamic or parameter indexes. Mojo now has a simple and explicit policy: if a type implements a __getitem_param__() or __getattr_param__() method and the indices are valid parameter expressions, the compiler will pick it (but will not support a __setitem__() pair). If not or if the indices are only valid runtime values, Mojo will try __getitem__()/__setitem__() as usual. This makes the behavior more predictable and explicit, but requires types to switch to the param method names if they desire parameter-style subscripting. This only affects a small number of special types like Tuple and VariadicPack.

• The @doc_private decorator has been renamed to @doc_hidden to better reflect its purpose of hiding declarations from documentation generation, rather than implying any change in access control. The old @doc_private name is still accepted but deprecated and will be removed in a future release.

Library changes

Conditional conformances

• Dict now uses real conditional conformances for Writable. The Dict type only conforms to Writable when both its key and value types do, enforced at compile time via where clauses.

• Standard library types now use conditional conformances, replacing previous _constrained_conforms_to checks:

  • Deque: Equatable, Hashable, Writable
  • Dict: Writable, Equatable, Hashable
  • InlineArray: Copyable, Equatable, Hashable, Writable
  • LinkedList: Equatable, Hashable, Writable
  • List: Equatable, Hashable, Writable
  • Optional: Hashable, Writable, Copyable, ImplicitlyCopyable
  • Set: Copyable, Comparable, Equatable, Hashable, Writable
  • Tuple: Copyable, Equatable, Hashable, ImplicitlyCopyable, Writable
  • Variant: Writable

Collections and iterators

• Dict internals have been replaced with a Swiss Table implementation using SIMD group probing for lookups. This improves lookup, insertion, and deletion performance—especially when looking up keys not in the dict—while increasing the load factor from 2/3 to 7/8 for better memory efficiency. The power_of_two_initial_capacity keyword argument has been renamed to capacity and now accepts any positive integer (it is rounded up to the next power of two internally, minimum 16).

• Dict now performs in-place tombstone rehashing when the table is full of tombstones but the live element count is low. This prevents unnecessary capacity doubling after repeated insert/delete cycles.

• StaticTuple now supports comparison operators. __eq__()/__ne__() are available when element_type: Equatable, and __lt__()/__le__()/__gt__()/ __ge__() are available when element_type: Comparable. All use lexicographic ordering with compile-time unrolled loops.

• Set.pop() now uses Dict.popitem() directly, avoiding a redundant rehash. Order changes from FIFO to LIFO, matching Python's unordered set.pop().

• Set.__gt__() and Set.__lt__() now use an O(1) len() check plus a single issubset() traversal instead of two full traversals.

• InlineArray now requires explicitly using literals for construction. For example:

  var a: InlineArray[UInt8, 4] = [1, 2, 3, 4]
  # instead of InlineArray[UInt8, 4](1, 2, 3, 4)

• The following types now correctly implement write_repr_to():

  • List, Set

• The itertools module now includes three new iterator combinators:

  • cycle(iterable): Creates an iterator that cycles through elements indefinitely
  • take_while[predicate](iterable): Yields elements while the predicate returns True
  • drop_while[predicate](iterable): Drops elements while the predicate returns True, then yields the rest

String and text

• The Stringable and Representable traits are now deprecated. Use Writable instead to make your types formattable as strings. Writable provides a default implementation, so in many cases simply adding Writable conformance is enough without manually implementing write_to() or write_repr_to(), however, you can manually implement these to get custom output.

• The stdlib is beginning to remove support for the Stringable and Representable traits in favor of the unified Writable trait. Most stdlib types have had their conformance to Stringable and Representable removed and the associated __str__() and __repr__() methods have been deprecated.

• The __reversed__() method on String, StringSlice, and StringLiteral has been deprecated in favor of the new codepoints_reversed() method. The new method name makes it explicit that iteration is over Unicode codepoints in reverse order, maintaining consistency with the existing codepoints() and codepoint_slices() methods. The deprecated __reversed__() methods will continue to work but will emit deprecation warnings.

• The StringSlice constructor from String now propagates mutability. If you have a mutable reference to a String, StringSlice(str) returns a mutable StringSlice. The String.as_string_slice() method is now deprecated in favor of the StringSlice(str) constructor, and String.as_string_slice_mut() has been removed.

• String.ljust(), String.rjust(), and String.center() have been renamed to String.ascii_ljust(), String.ascii_rjust(), and String.ascii_center(). Likewise for their equivalents on StringSlice and StaticString.

• String.resize() will now panic if the new length would truncate a codepoint. Previously it would result in a string with invalid UTF-8.

• String.resize() will now panic if fill_byte is >=128. Previously it would create invalid UTF-8.

• Subscripting into String and StringSlice will now panic if the index falls in the middle of a UTF-8 encoded codepoint. Previously they would return invalid UTF-8. This panic is unconditional. Use .as_bytes()[...] if you really want the previous behavior.

• StringSlice[byte=] subscripting now returns a StringSlice instead of a String. This is consistent with range-based subscripting.

• Subscripting String and StringSlice by byte position will now return an entire Unicode codepoint. Previously it would return a single byte, and produce invalid UTF-8 if the index fell on the starting byte of a multi-byte codepoint.

• String, StringSlice, and StringLiteral's .format() method now require their arguments to be Writable.

• TString.write_to() now uses a compact encoding for format strings. The format string is flattened at compile time into NUL-terminated literal segments, producing considerably smaller static data and faster runtime than the previous struct-based precompiled entries.

• Formatting compile-time format strings (StringLiterals) no longer allocates memory. It uses global_constant to store what would be heap-allocated parsed formatting data.

• T-strings now support the raw prefix (rt"...") which preserves backslashes as literal characters while still supporting interpolation.

  var name = "Mojo"
  print(t"C:\{name}\Documents") # prints "C:\Mojo\Documents"

• Subscripting String and StringSlice now requires a named parameter for range indexing. For example, s[1:3] is now s[byte=1:3].

Type system and traits

• Bool no longer conforms to the Indexer trait. Previously, Bool could be used to index into collections (for example, nums[True]), which is not desirable behavior for a strongly-typed language. Use Int(my_bool) to explicitly convert a Bool to an index.

• The following types now conform to Writable and have custom implementations of write_to() and write_repr_to().

  • Tuple
  • Variant
  • Optional

• All traits and structs with the @register_passable("trivial") decorator now extend the TrivialRegisterPassable trait. The decorator is removed from them.

• A new utils/type_functions module was added for holding type functions. Type functions are comptime declarations that produce a type from compile-time parameter inputs. Unlike regular fn functions which accept and return runtime values, type functions operate entirely at compile time—they take comptime parameters and evaluate to a type, with no runtime component.

  • ConditionalType—A type function that conditionally selects between two types based on a compile-time boolean condition. It is the type-level equivalent of the ternary conditional expression Then if If else Else.

• reflection/traits has been added, providing compile-time meta functions (AllWritable, AllMovable, AllCopyable, AllImplicitlyCopyable, AllDefaultable, AllEquatable) that evaluate to True if all types in a variadic type list conform to the corresponding trait.

• Added the UnsafeNicheable and UnsafeSingleNicheable traits to std.utils. These traits allow types to expose known-invalid bit patterns ("niches") that can be used by containers like Optional and Variant to avoid storing a separate tag, so that size_of[Optional[T]]() == size_of[T](). UnsafeSingleNicheable is a simplified subtrait for the common case where a type has exactly one niche value.

  • Variant and Optional now automatically take advantage of this: when the variant types qualify, the discriminant tag is elided entirely, reducing the size of the variant. For example, size_of[Optional[T]]() == size_of[T]() for any T that implements UnsafeNicheable.
  • Variant also only works with Movable types in the interim instead of AnyType due to some compiler limitations.

Math and numeric types

• Implicit conversions from Int to SIMD are now deprecated, and will be removed in a future version of Mojo. This includes deprecating conversions from Int to specific SIMD scalar types like Int8 or Float32.

  Note: The experimental mojo build --experimental-fixit command may be useful in assisting with migrating your code to reflect this change.

  Code currently relying on implicit conversions, for example:

  def foo(arg: Int) -> Float32:
      return arg

  should be changed to use an explicit conversion:

  def foo(arg: Int) -> Float32:
      return Float32(arg)

  Occasionally, when an implicit conversion was happening from a scalar Int to a wider SIMD value, the compiler will suggest a change to make the conversion explicit that is somewhat verbose, performing both the type conversion and the "splat" in a single step:

  var bits: SIMD[DType.uint8, 16] = ...
  - var y = bits >> (j * 4)
  + var y = bits >> SIMD[DType.uint8, 16](j * 4)

  a simpler change is to make the type conversion explicit, and let the "splat" continue to happen implicitly (which will remain supported):

  var bits: SIMD[DType.uint8, 16] = ...
  - var y = bits >> (j * 4)
  + var y = bits >> UInt8(j * 4)

  A similar overly verbose suggestion can be emitted relating to LayoutTensor.element_type, where the compiler may suggest a change of the form:

  - tensor[i] = i * l
  + tensor[i] = LayoutTensor[DType.uint32, Layout(IntTuple(-1)), stack].element_type(i * l)

  where a simpler change is sufficient:

  - tensor[i] = i * l
  + tensor[i] = UInt32(i * l)
  
  # Note: If the tensor's `dtype` is not statically known, this works as well:
  + tensor[i] = Scalar[tensor.dtype](i * l)

• SIMD's safe division operators (__floordiv__, __mod__, __divmod__) now return safe results in an elementwise fashion. They previously returned a zero result if any element of the divisor was zero:

  comptime Int32x2 = SIMD[DType.int32, 2]
  
  var a = Int32x2(99, 99)
  var b = Int32x2(4, 0)
  # Now returns [24, 0]
  # Previously returned [0, 0]
  print(a.__floordiv__(b))

• Int.__truediv__() now performs truncating integer division, returning Int instead of the previously deprecated Float64. Use explicit Float64 casts for floating-point division.

• Documentation for SIMD.__round__() now clarifies the pre-existing behavior that ties are rounded to the nearest even, not away from zero.

• Int.write_padded() now accounts for a negative sign when calculating the width, resulting in a consistent width regardless of sign:

  Int(1).write_padded(s, 4)  # writes "   1"
  Int(-1).write_padded(s, 4) # writes "  -1"

• SIMD now has a write_padded() method for integral DTypes, matching the behavior of Int.write_padded(). The padding is added elementwise. Unlike SIMD regular printing, there are no spaces added between elements by default:

  Int32(1).write_padded(s, 4)  # writes "   1"
  Int32(-1).write_padded(s, 4) # writes "  -1"
  
  # "[   1,  -1,   0,1234]"
  SIMD[DType.int32, 4](1,-1,0,1234).write_padded(s, 4)
  # "[255,255]"
  SIMD[DType.uint8, 2](255).write_padded(s, 1)

• Added comb(n, k) and perm(n, k) to std.math, matching Python's math.comb() and math.perm(). comb(n, k) computes the binomial coefficient C(n, k) without computing full factorials, returning 0 when k > n. perm(n, k) computes permutations P(n, k); omitting k (default -1) returns n!.

• The builtin.math module has been merged into math. The traits Absable, DivModable, Powable, Roundable and functions abs(), divmod(), max(), min(), pow(), round() are now part of the math module and continue to be available in the prelude. Code that explicitly imported from builtin.math should update to import from math instead.

• Math functions in std.math (exp(), exp2(), log2(), erf(), tanh(), sin(), cos(), tan(), acos(), asin(), atan(), atan2(), acosh(), asinh(), atanh(), cosh(), sinh(), expm1(), log10(), log1p(), logb(), cbrt(), erfc(), j0(), j1(), y0(), y1()) now use where dtype.is_floating_point() clauses on their signatures instead of __comptime_assert checks in their bodies. This provides better compile-time error messages at the call site. Callers using these functions with generic dtype parameters may need to add evidence proving (either a where clause or __comptime_assert) that their type is floating point.

Pointer and memory

• Added uninit_move_n(), uninit_copy_n(), and destroy_n() functions to the memory module for efficient bulk memory operations. These functions handle moving, copying, and destroying multiple values in contiguous memory, with automatic optimization for trivial types using memcpy. They encapsulate the common pattern of checking __move_ctor_is_trivial, __copy_ctor_is_trivial, or __del__is_trivial and selecting the appropriate implementation. The List collection now uses these functions internally for improved code clarity and maintainability.

• The Origin struct now takes the underlying MLIR origin as a parameter instead of storing it. This follows the design of IntLiteral and related types, and fixes some memory safety problems.

• UnsafeMaybeUninit has been renamed as such, and its methods have had their names updated to reflect the init name. It also now exposes a zeroed() method to get zeroed out uninitialized memory. It also no longer calls abort() when being copied or moved, allowing for more practical uses.

• Span[T] is no longer restricted to Copyable types. It now works with T: AnyType. There are a few restrictions including iteration requiring T: Copyable.

GPU programming

• lane_group_sum(), lane_group_max(), and lane_group_min() in std.gpu.primitives.warp now always broadcast the reduction result to all participating lanes, using optimized hardware-specific paths (AMD DPP, Blackwell redux, or butterfly shuffle pattern). The previous lane_group_sum_and_broadcast(), lane_group_max_and_broadcast() functions are deprecated—use the short names instead.

• TileTensor now supports hierarchical indexing. For example, a TileTensor with shape (4, (3, 2)) can be indexed by (1), (1, 1), or (1, (1, 1)).

• TileTensor now supports flattening up to depth-4.

• Many kernels in nn have been migrated to use TileTensor. We will have more documentation on TileTensor and its uses over the coming weeks.

FFI and system

• The ffi module is now a top-level module in the standard library, rather than being nested under sys. This improves discoverability of FFI functionality. Update your imports from from sys.ffi import ... to from ffi import ....

• Added UnsafeUnion[*Ts], a C-style untagged union type for FFI interoperability. Unlike Variant, UnsafeUnion does not track which type is stored (no discriminant), making it suitable for interfacing with C unions and low-level type punning. The memory layout exactly matches C unions (size is max of elements, alignment is max of elements).

  All element types must have trivial copy, move, and destroy operations, matching C union semantics where types don't have constructors or destructors.

  Construction is explicit (no implicit conversion) to emphasize the unsafe nature of this type. All accessor methods are prefixed with unsafe_ to make it clear that these operations are unsafe.

  from ffi import UnsafeUnion
  
  # Define a union that can hold Int32 or Float32
  comptime IntOrFloat = UnsafeUnion[Int32, Float32]
  
  var u = IntOrFloat(Int32(42))
  print(u.unsafe_get[Int32]())  # => 42
  print(u)  # => UnsafeUnion[Int32, Float32](size=4, align=4)
  
  # Type punning (reinterpreting bits)
  var u2 = IntOrFloat(Float32(1.0))
  print(u2.unsafe_get[Int32]())  # => 1065353216 (IEEE 754 bits)

• The env_get_bool(), env_get_int(), env_get_string(), and env_get_dtype() functions in the sys.param_env module have been renamed to get_defined_bool(), get_defined_int(), get_defined_string(), and get_defined_dtype() in the new sys.defines module. The new names better reflect that these functions read compile-time defines (set via -D), not runtime environment variables. The is_defined() function has also moved to sys.defines without renaming. The old names in sys.param_env are deprecated but still available.

Testing

• The testing module now provides assert_equal and assert_not_equal overloads for Tuple, enabling direct tuple-to-tuple comparisons in tests instead of element-by-element assertions. Element types must conform to Equatable & Writable.

• assert_equal and assert_not_equal now work with types implementing Writable.

Other library changes

• Changed CompilationTarget.unsupported_target_error() to return Never and removed its result type parameter.

• Removed DType.get_dtype[T]() and DType.is_scalar[T](). These were low-level operations for extracting the DType of a SIMD in generic code. There are better alternatives available in Mojo today using reflection capabilities.

• perf_counter_ns() now returns correct nanoseconds on GPU instead of raw cycle counts. Previously on NVIDIA GPUs it used clock64 (a cycle counter dependent on GPU core clock frequency); it now uses globaltimer which provides actual nanosecond resolution. On AMD GPUs, it now uses s_memrealtime (a constant-speed real-time clock) instead of s_memtime (a cycle counter).

• The DimList type has moved to representing its dimensions as parameters to the type instead of values inside the type, directly reflecting that the dimensions are known at compile time. Change DimList(x, y) to DimList[x, y]().

Tooling changes

• The Mojo compiler now accepts conjoined -D options in addition to the non-conjoined form as before. Now, both -Dfoo and -D foo are accepted.

• mojo build now supports several --print-* options for discovering target configuration and supported architectures:

  • --print-effective-target: Shows the resolved target configuration after processing all command-line flags.
  • --print-supported-targets: Lists all available LLVM target architectures.
  • --print-supported-cpus: Lists valid CPU names for a given target triple (requires --target-triple).
  • --print-supported-accelerators: Lists all supported GPU and accelerator architectures (NVIDIA, AMD, Apple Metal).

• mojo format now only formats Mojo files (.mojo, .🔥) by default when run on a directory. Previously it would also format Python files, which conflicted with Python-specific formatters in pre-commit hooks. Users who want to format Python files can use mblack directly.

• mojo format now supports --print-cache-dir (hidden, use --help-hidden to see it) to display the path to the formatter cache directory.

• mojo build --emit=asm now also emits GPU kernel assembly files alongside the host .s output. For NVIDIA targets, PTX is written as <out>_<kernelfn>.ptx; for Apple Metal targets, LLVM IR is written as <out>_<kernelfn>.ll; for AMD targets, .amdgcn files are written. Multiple kernels generated from the same function are disambiguated with a numeric suffix (for example, <out>_<kernelfn>_1.ptx).

• mojo doc is now more consistent with Python in its treatment of private members. Any member name starting with an underscore (_) is treated as private unless it is a "dunder" member (starting and ending with double-underscores). In practice this means that members that start but don't end with double underscores (__example()) are now treated as private. Dunder methods that start with __mlir are now treated as public unless marked with the @doc_private decorator.

❌ Removed

• The .🔥 (flame) and 📦 (package) emoji file extensions are no longer supported. Use .mojo for all Mojo source files and __init__.mojo for package initialization files. The emoji extensions were removed to simplify the tooling and improve compatibility across different systems and editors.

• The owned keyword has been removed. Use var for parameters or deinit for __moveinit__/__del__ arguments as appropriate.

• Dict.EMPTY and Dict.REMOVED comptime aliases have been removed. These were internal implementation details of the old hash table design.

• The @nonmaterializable decorator has been renamed to @__nonmaterializable. This decorator should not be used outside the standard library, and might be removed in a future release.

🛠️ Fixed

• Fixed a bug where Mojo incorrectly passed or returned structs in extern C function calls. The compiler now applies platform ABI coercion (System V AMD64 on x86-64, AAPCS on ARM64) when lowering external calls, decomposing structs into the register types the C ABI requires—matching the behavior of Clang and Rust. This resolves silent wrong-answer bugs when calling C functions that take or return struct types.

• Issue #5845: Functions raising custom type with conversion fails when returning StringSlice

• Issue #5722: __del__ incorrectly runs when __init__ raises before all fields are initialized.

• Issue #5875: Storing SIMD[DType.bool, N] with width > 1 to a pointer and reading back element-wise now returns correct values.

• StringSlice.find: Fixed integer overflow bug in SIMD string search that caused searches to fail when searching for strings longer than simd_width_of[DType.bool]() and haystacks larger than UInt16.MAX.

• LinkedList.reverse(): Fixed missing prev pointer updates, which caused __reversed__() to produce wrong results after reversing.

• Mojo would previously consider types Movable if they had a __moveinit__() method, even if they didn't conform to Movable. Movability is now tied to the conformance which implies the method.

Special thanks

Special thanks to our community contributors:

Amit Vijairania (@avijaira), Bernardo Taveira (@bertaveira), Brian Carroll (@brian-carroll), Brian Grenier (@bgreni), Byungchul Chae (@byungchul-sqzb), Derek Veit (@DerekVeit), Dylan Walker Brown (@walkerbrown), elpres (@elpres), Evan Owen (@ulmentflam), Joseph Wakeling (@JosephWakeling), josiahls (@josiahls), Krish Gupta (@KrxGu), lamija-i (@lamija-i), Mahendra Singh Rathore (@mahendrarathore1742), Manuel Saelices (@msaelices), martinvuyk (@martinvuyk), minkyu (@kkimmk), nejraberberovic (@nejraberberovic), Parsa Bahraminejad (@prsabahrami), pei0033 (@pei0033), Sören Brunk (@sbrunk), Taesu Kim (@tae-su-kim), Tolga Cangöz (@tolgacangoz), turakz (@turakz)