Mojo 1: Looks like Python is more rusty

Modular, a company owned by Qualcomm, has released the stable version 1.0 of its programming language Mojo. The language, which resembles Python in appearance, incorporates features inspired by Rust, making it more efficient and uniform. The update includes improvements such as a unified variable declaration using `var`, streamlined closures, and the merging of previously separate types `Pointer` and `UnsafePointer` into a single type with explicit safety markers through the `unsafe_` prefix. The release coincides with version 26.5 of Modular's proprietary AI platform MAX, both made available in the same GitHub release. MAX uses calendar-based versioning, while Mojo transitions to semantic versioning with this first stable release. For the first time, parts of Mojo’s interfaces are explicitly marked as stable. One of the most significant changes involves function definitions. Previously, Mojo used `def` for Python-like functions and `fn` for stricter checked functions. With version 1, Modular has removed `fn`, replacing it with `def`. This change introduces stricter rules for `def`, requiring explicit exception handling via `raises` if exceptions are to be thrown. The compiler now treats `def` as subject to these stricter rules, meaning code written with `fn` might fail under the new standards unless adapted. A new lambda syntax has also been introduced, described as “Python-style” but requiring parentheses and type annotations. Instead of Python’s `lambda x: x 2`, Mojo uses `lambda (x: Int) -> Int: x 2`. The compiler has also gained enhanced error detection capabilities. It can identify invalid references, particularly in scenarios where memory management could lead to crashes or security vulnerabilities. For example, if a list grows beyond its allocated space and a reference points to the old location, Mojo flags this during compilation rather than runtime. A sample program illustrates this, showing how a reference to a list element becomes invalid after appending new data, leading to a clear error message. Modular aims to address the two-language problem common in AI development, where Python dominates due to its ease of use but lacks performance, often relying on C, C++, or CUDA libraries for computation. Mojo offers static typing, an ownership model without garbage collection, and direct hardware control, positioning it closer to C++ and Rust than Python despite its familiar syntax. Modular uses Mojo as the foundation for MAX and its cloud services. Founded in January 2022 by Chris Lattner, the original developer of LLVM and Swift, and Tim Davis, responsible for TensorFlow, XLA, and TPU at Google, Modular built upon their work on MLIR, which now forms the basis of Mojo. Since July 29, 2026, Modular has been part of Qualcomm, though Mojo, MAX, and the Modular Cloud remain independent products. An example of Mojo code shows its structure: ```python def square(x: Int) -> Int: return x * x def main(): var value = 42 print(square(value)) ``` Type annotations such as `x: Int` and `-> Int` are required to ensure clarity and correctness in the language.