Mojo 1.2 introduces pattern matching, expands GPU math support, and improves compilation speed, alongside updates to strings, collections, and generics.

Profitez des vidéos et de la musique que vous aimez, mettez en ligne des contenus originaux, et partagez-les avec vos amis, vos proches et le monde entier.

Mojo 1.2 introduces pattern matching, expands GPU math support, and improves compilation speed, alongside updates to strings, collections, and generics.

Mojo 1.2 introduces pattern matching, expands GPU math support, and improves compilation speed, alongside updates to strings, collections, and generics.

Back in August Modular's Mojo language was open-sourced following the acquisition of Chris Lattner's company by Qualcomm. The latest achievement now out of the company is their MAX software being fully opened up with the entire source tree available...

Back in August Modular's Mojo language was open-sourced following the acquisition of Chris Lattner's company by Qualcomm. The latest achievement now out of the company is their MAX software being…

I'm seeing postings on other forums about new languages whose main feature seems to be a more relaxed borrow checker than Rust. This has come up many times before. I had a go at this back in 2024. The consensus seemed to be that it wasn't enough of a pain point to justify language changes. But now we are seeing more activity in this area. Everybody has a new "improved Rust" language: * Ante * Valen/Vail * Zeta * also Carbon, Fang, and Mojo have been mentioned. The Ante people identify two problems. One is the scope of a borrow extending beyond the last point of use. See the link above for an example. That's supposed to be fixed in the Polonious borrow checker. The other is the good old back references problem. That can be handled in Rust with **Rc** , **RefCell** , **Weak** , **downgrade** , and **upgrade**. Ir works, but the resulting code is clunky. Dangling weak pointers are possible, although they lead to detected errors. Circular ownership and resulting memory leaks are possible and not easily detected. So what's current thinking on this? Both problems seem fixable without a new language.

Back in August Modular's Mojo language was open-sourced following the acquisition of Chris Lattner's company by Qualcomm. The latest achievement now out of the company is their MAX software being fully opened up with the entire source tree available...

In 2022, Chris Lattner left Google and started a company to fix one of software’s more embarrassing open secrets: the language everyone used to build AI could not actually run AI fast enough to ship. Python had won the research world on readability. It was losing it on performance. Lattner had good…

An analysis of robots.txt files from 388 Canadian websites finds French-language newsrooms block AI the most, several major broadcast newsrooms block outdated AI crawler names, and 16 sites block a Canadian AI developer. Otterburn Park, QUEBEC, Oct. 20, 2026 (GLOBE NEWSWIRE) -- Seven in ten Canadian news websites now ask AI crawlers to stay out, while not one of the country's banks, insurers or fintechs does, according to a new study from Chateau Mojo, a Quebec-based SEO and AI search consultancy.

For some reason, I’d lost a little of my reading mojo and just couldn’t get excited about books. I returned two to the library without finishing them, I couldn’t decide what to re…

This is similar to NLL borrowing. And there is already a language that does this, namely Mojo

A garbage collector is anything that manages memory automatically through runtime tracking. Rc and Arc track it via runtime counter. Rust is not the only language that uses ref counting, Python's garbage collector is ref counting as its primary mechanism (the generational GC only cleans up what ref counting fails to handle, such as circular references) There's a mistake, ref counting in Mojo doesn't apply to all ref types. It only happens when you return like this: // a is &String by default, so the reference is first class, where in Rust pass by move is first class // you cloud annotate the a manually with ref a, but it is not needed // for function parameters, the default is already &T // the return value default is T, so only need typing ref in return type (a: String) -> String: return a Instead of making it a compile error saying "can't copy/move String from a reference parameter String", it makes it copy the reference using a ref counter If you write: -> ref[origin] String: return string That's normal like Rust Or if you write: -> String: return string^ That becomes a move and only succeeds if the parameter is not a reference but a `var` which can pass ownership So it's incorrect to say that ref counting happens on all ref types, it only happens with strings, and if you explicitly write `ref` it won't use the copy reference by ref counter. In Mojo you don't need to annotate the function parameter to get &T. But you need it for return type, and variable declaration, like: var a = "abc" ref b = a @CoolSchnoodle The consecutive reply limit is 3 messages, so I'm responding to your message by extending the last comment as suggested by the error message That misses the point. The point isn't that I don't know how to make it autovectorize, I was showing the downside of those constructs in that they prevent the auto vectorization optimization pass that would otherwise succeed if they weren't present in the input code of the autovectorizer. You moved it outside the loop, whereas the input code for auto vectorization is the loop body itself. Auto vectorizing a loop will fail if there's a jump instruction inside it that the compiler fails to remove or move to outside loop, and I'm showing that `RefCell` and `Cow` are among the things that introduce that. Then you suddenly show `Cell` (which is not `RefCell`, it doesn't have what `RefCell` has because it only works with types that implement `Copy`, `i32` implements `Copy`, try replacing it with `Cell<String>` it won't work, whereas `RefCell` can take a reference of complex data types like String, Vec, etc), and move the `Cow` outside the loop, which is not the point because it doesn't happen inside loop, so it doesn't fix the downside, but dodge the downside. Because what was being the problem is the downside of `RefCell` and `Cow` when called inside a loop. Unless you're demonstrating how to keep auto vectorization working with `RefCell` and `Cow` inside the loop

Mojo 1.1 opens its compiler to external contributions, giving developers new opportunities to participate in the programming language’s development. The post Mojo 1.1 Programming Language Opens Its Compiler to External Contributions appeared first on Linux Today.

To understand the Mojo model, you don't need to learn anything special, because it works the same way as every other programming language (whether GC or manual memory management), once memory is no longer used it is freed, and if it is still being used, for example passed into another variable or into a function, it is freed after that last user finishes, which is naturally the correct memory behavior of freeing it after it is no longer needed, not freeing after the end of scope. Since var a in the abc function is no longer used and abc returns a different value, var a is freed inside the abc function. In Mojo it is very easy, the code adapts to you, not you adapting to rigid rules. So when you return var a from the abc() function, the value is now being used, so it stays alive for as long as the caller uses the return value, as soon as the caller stops using it, it will be freed. The callee has no business ensuring and dictating how long the return value lives. It is the caller that decides. If you use the return value: var a = abc() ref b = a fn(a) fn2(b) As long as the value is still being used, it will automatically stay alive. As soon as the value stops being used: // for example here I stop using everything that uses a, so a is automatically freed right after the last usage which is fn2() The `'static` is itself a lifetime annotation leaking implementation detail into the signature. The caller now must know the value is static. If you later change the implementation to return a dynamically constructed string, the signature breaks and every caller breaks with it. That's the encapsulation violation

📄 Articles; 🧑‍🏫🌍🛠️📈 Agent Skills: Equipping agents for the real world with Agent Skills; 📚 Books; 🏘️🧱🏗️ A Pattern Language: Towns, Buildings, Construction; ⌨️🤖 Prompt Engineering for LLMs: The Art and Science of Building Large Language Model-Based Applications; 🐱👍 Think Like a Cat: How to Raise a Well-Adjusted Cat - Not a Sour Puss; 🐱👑 Total Cat Mojo: The Ultimate Guide to Life with Your Cat; 📺 Videos; ⚡🔋💪 The Mitochondria Protocol: How to Actually Fix Your Energy.

Mojo 1.1 now accepts external compiler contributions, while Modular has also moved internal compiler issues to public GitHub trackers.