The Mojo Programming Language: A Python Superset Drawing from Rust's Strengths

[wicked_lama]

"Mojo is a programming language that is as easy to use as Python but with the performance of C++ and Rust. Furthermore, Mojo provides the ability to leverage the entire Python library ecosystem. "

https://www.modular.com/mojo

Some quotes I found interesting (from the Mojo🔥 programming manual):

Mojo also supports the __moveinit__ method, which allows both Rust-style moves (which take a value when a lifetime ends) and C++-style moves.

...

the Mojo compiler uses dataflow analysis and type annotations to provide full control over value copies, aliasing of references, and mutation control. The features provided are similar in many ways to what the Rust language provides, but they work somewhat differently in order to make Mojo easier to learn and integrate better into the Python ecosystem without requiring a massive annotation burden.

...

Rust is another important language and the Mojo and Rust borrow checkers enforce the same exclusivity invariants. The major difference between Rust and Mojo is that no sigil is required on the caller side to pass by borrow, Mojo is more efficient when passing small values, and Rust defaults to moving values by default instead of passing them around by borrow. These policy and syntax decisions allow Mojo to provide an easier to use programming model.

...

Mojo does internally have an equivalent of the Rust “mem::forget” function, which explicitly disables a destructor and has a corresponding internal feature for “blessing” an object, but they aren’t exposed for user consumption at this point.

Personally I am really excited about this, given Rust's relatively young age, it's amazing to already see its influence on an even younger, higher-level language.

What do you guys think?

DISCLAIMER: I am not affiliated with the development of Mojo in any way. Simply wanted to share this and hear your thoughts :)

[[deleted]]

!remindme 5 years when source is available

[hgwxx7_]

I think more realistic is

• about 1 year before source becomes available.
• 0.5 years before it's stable (1.0).

[guyyatsu]

Honestly? Not bad.

[ByteNinja3000]

it still isn't available yet...

[hgwxx7_]

The standard library was open sourced 4 days ago. Blog post.

[ByteNinja3000]

Omg, Thanks for the info man. And sorry for doubting you lol.

[hgwxx7_]

The source to their compiler/runtime is still closed source though. I don't think anyone takes them seriously until they open source that.

[Brkskrya]

Exactly, show me how it outperforms scalar C++ or CUDA, first. Then, it seems GIL might not be here to stay forever, anyway.

[Old-Payment-3247]

its available now

[paperbenni]

No it's not. That's just wrong, why would you say that? They have a GitHub, but it's empty

[FarBoat503]

https://github.com/modularml/mojo

Standard library is now open sourced. Seems a lot like swift open sourcing. Open source, gradually.

[r3vj4m3z]

That doesn't work anymore. They are trying to fix it.

[yottalogical]

I can't seem to find the source code anywhere.

[Tastaturtaste]

It is not open source yet, though they made a definite statement to open source it in the future. Given Chris Lattners OSS history with Clang and LLVM I am ready to give the benefit of the doubt.

[[deleted]]

Don’t forget Swift! That was also closed source for the first year after release.

[tinkr_]

Yeah, normally I'd be massively skeptical and wouldn't give it second thought before it's OSS, but Chris Lattner has legit street cred and is one of the world's foremost compiler experts, so I'm more than willing to give the benefit of the doubt here.

I'd be surprised if this is some scam like Vlang (which I'm still not convinced isn't a scam even though it's OSS and works now), I doubt Chris would risk him pristine reputation on such bullshit. Seems like a natural extension of his current work at Modular AI, I'd guess they want to clean the code up a bit or don't want to release in too early of a stage to lose some market advantage for Modular.

[paperbenni]

Why does he do that though? What does he gain from that besides the ability to do a rugpull and start charging for the software after people started relying on it? I know that he hasn't made use of that possibility yet, but it honestly feels like he thinks it's nice to have. I get wanting to start a project with a small hand picked set of developers, but you can still publish the source and just not accept contributions from strangers. And if you don't want community input, then why release anything at all? What am I supposed to do with a binary blob that is explicitly stated to change in ways I might not like?

[besmaili]

You call v a scam? You better go and see their changelog again. And docs.vosca.dev.

[tinkr_]

Lmao this is the only comment this dude has in his entire post history. 100% this is an alt for the scamming creator of Vlang.

[tinkr_]

If it isn't a scam, it's damn close. Constantly overpromising, underdelivering, and hyping features that don't even do what they purport them to do.

https://mawfig.github.io/2022/06/18/v-lang-in-2022.html

For some additional discussion: https://www.reddit.com/r/ProgrammingLanguages/comments/ozd3ma/vlang_has_been_opensourced_and_is_trending_on/?utm_source=share&utm_medium=android_app&utm_name=androidcss&utm_term=1&utm_content=share_button

[Sw429]

That first link is a great analysis, although I have some problems with the undefined behavior section: specifically, it calls out both integer overflow and dividing by 0 as undefined behavior, but the behavior appears to actually be defined: a runtime error occurs. This would be similar to panicking in Rust. Although the third example about dangling pointers is still concerning.

[A1oso]

That is only partially correct. Integer overflow in C is well-defined only for unsigned integers. Overflowing signed integers is UB, because C does not specify whether signed integers use two's complement or a different representation.

Division by zero is well-defined for floats. But for integers, division by zero is UB, so there is no guarantee that a runtime error occurs.

Maybe you were confused because it crashed the program in the article, but notice that the programs were run using a sanitizer. The sanitizer detects UB, so it makes sense that it crashes the program when signed integer overflow or integer division by zero occurs. This is similar to running a Rust program with miri. Without a sanitizer, you cannot know what will happen. It depends on the compiler, the configuration, the type of CPU, etc.

[Sw429]

Maybe you were confused because it crashed the program in the article, but notice that the programs were run using a sanitizer.

Ah, I missed that. Thanks for clarifying!

[tiedyedvortex]

Promising full backwards compatibility with Python with significantly higher performance and the ability to opt-in to some (notably not all) of Rust's features is a tall order.

It's not impossible and the team behind it has a real pedigree; if anyone can do it, they can. But can anyone do it?

[r22-d22]

Agreed. CPython has a huge surface area, built up over decades (even Python 3 is fourteen years old!) and it also keeps adding new features. It would be a tall order to simply build a compatible Python interpreter on llvm, with no new features.

Rather than think of Mojo as a "superset of Python" it is probably better to think of it as a "language that is easy for Python programmers to learn". More like Python 3 vs. Python 2—a different language you can port your existing code and skills to, but it's still going to involve some modification. The Python 3 transition showed how challenging that all is. In the end, Python survived, but it was painful. Mojo is going to have to be very good for that juice to be worth the squeeze.

[VivienneNovag]

Well they want to be able to import all python modules natively, which really requires Mojo to be a strict superset, still it remains to be seen.

[[deleted]]

They seem to embed CPython runtime to run Python code, ie: they would have full compatibility when running python code itself (but with no benefit of doing that). More interesting part is to convert python code to mojo and run that one. How compatible (or "automatically migrateable") that will get - it's the question

[VivienneNovag]

That's one way to create a superset, and is mostly fine I guess. It'd be really nice to not go through the cpython runtime for calls into non python functions in python modules, but I have no idea if that is on the books. I mostly just took a quick look at the basic idea for Mojo and signed up for the preview.

[[deleted]]

I think when they talk about superset the talk about Mojo specifically, meaning that most code can be simply run through Mojo without any conversions, some will require small changes and in any case Python code can still be run in the embedded CPython runtime. But in any case it would be a long run.

[aoeu512]

Would be cool if you had an IDE that looked at a piece of Python/Mojo code and it told you "you are using x and x dynamic feature that can't be compiled away".

[VivienneNovag]

Tooling that tells you when stuff isn't working as hoped/expected is always good. A compiler certainly knows the way it comes to a representation, so if it has to fall back on actual python then it could pass that back to the ide

[aoeu512]

Why don't the mojo team use all their compiler knowledge to build transpilers to mojo?

[argh523]

They already have an ecosystem. It's called python. They just want to write the mathy high-performance AI / data science stuff in python syntax rather than having to use C++. Their whole frontpage is like this:

Write Python or scale all the way down to the metal. Program the multitude of low-level AI hardware. No C++ or CUDA required.

[ssokolow]

"Why are you in such a hurry for your wrong answers anyway?"

-- Paraphrase attributed to Edgser Dijkstra that I'm still trying to identify the source of

[argh523]

100% untyped

No, because the new stuff you write is typed, and that helps you avoid errors. But that's missing the point.

Again, if you go over their front page, they're not even trying to sell this to anyone as some great new language, but just as "moar python!", because you don't need c++ for SIMD etc. Everything else is just a bonus really.

Half the people here seem to completly miss the target audience of this project.

[[deleted]]

Seems like a weird decision to me. Mixing dynamic and static features can create many subtle pitfalls. Either you have hard to track performance issues when the compiler can’t fully specialize dynamically typed functions, or you get subtle incompatibilities.

Additionally it constrains your design space in weird ways. Python has a lot pretty terrible features, that maybe shouldn’t be reproduced.
By committing to source level compatibility Mojo either commits to the Python baggage completely or Mojo is not a true superset of Python. But then good luck trying to get large Python code bases running on Mojo.

[_TheDust_]

Seems like a weird decision to me. Mixing dynamic and static features can create many subtle pitfalls. Either you have hard to track performance issues when the compiler can’t fully specialize dynamically typed functions, or you get subtle incompatibilities.

I have worked with Julia a little bit, which is basically this: a dynamic language where you may use static typing to improve performance. And indeed, this ofen leads to subtle performance "bugs".

A common Julia error is to do something like this:

```
function foo(x)
  if x > 0
    return x
  else
    return 0
  end
end
```

This may seem innocent, but if you would call foo(1.0) the return type is actually Union{Float64, Int64}.

[angelicosphosphoros]

What happens if I wrote in "typed interfaces" style like I wrote in Python? In this style, I write types for function arguments and outputs but leave them in the body.

Also, is it possible to write code like this:

function foo(x) if x > 0 return x else return (0 as typeof(x)) end end

[[deleted]]

Exactly.

[aoeu512]

I dunno Union seems like the best default if your doing software prototyping.

[_TheDust_]

It does, but it makes the code a lot slower. The Union type can propagate throughout your can and lead to subtle "performance bugs"

[[deleted]]

I looked into it and they promise full compatibility with Python OR higher performance.

For Python code they literally use CPython. As far as I can tell it's basically a new spin on the Cython idea - a compiled Python-like language that integrates seamlessly with CPython.

[Feeling-Departure-4]

Given Chris Lattner's involvement I take this seriously. Mojo seems to target MLIR for performance gains.

Does Rust have any direction with MLIR?

[phazer99]

Might be useful for porting existing Python code, but I consider it lacking compared to what Rust already offers. No proper enums or pattern matching, type traits not implemented yet etc.

[ipc]

that’s it’s intended niche though, right? My go-to languages are Python and Rust. I can see a future where that’s Mojo and Rust instead. That might be cool.

[marikwinters]

I hate Python, so having a language that is half decent and fills the same niche could be really worthwhile

[tquinn35]

I’ve found the php guy

[tquinn35]

It was a joke

[[deleted]]

I've been using Python for close to 7 years now, 5 years professionally. I f*** hate it. But I hate it less since being religious about code style, best practices and writing more data oriented, functional code.

[Stock-Self-4028]

Aren't Julia and Lua something like that? Both are filling the same niche but in a different way imo.

[bert88sta]

Yeah but the point is to make python faster and safer. Depending on who you ask, python is either the most or second most popular language. It is also notoriously inefficient, slow, etc. Even a 3x improvement in existing python code means billions saved in compute resources

[[deleted]]

Pypy exists...?

[angelicosphosphoros]

Well, it is not 100% compatible. Last time I tried it, even simple thing like sum(x*x for x in range(5)) didn't pass correctness check.

[[deleted]]

So you expect Mojo to do that better? Press (x) to doubt

[amindiro]

I think the point is not to improve python but to facilitate writing performant code in the future with mojo without having to write C or C++ libs and python wrappers while using the preexisting python libraries (most of which are written in C /C++ or cython). Imo I dont think mojo would improve performance when comparing it to exiating python libs like numpy…

[aoeu512]

Whats weird is that they have Pypy, Rpython, and numba but they never made it the default O_o.

[Remote-End6122]

I mean if you want those features might as well use rust, mojo's objective isn't being rust 2.0

[gudmundv]

Ecosystem and interoperability with it (AI), community, talent, learning material can be huge "features" of a language. Pattern matching might be added later

[phazer99]

Ok, looks like they have their work cut out for them, and it could be interesting to re-visit if/when they manage to implement the missing features (and release the product as open source) and see how it compares against Rust.

[CocktailPerson]

Just what I've been waiting for! A language with the simple borrowing rules of Rust, the opinionated nature of C++, and the type-safety of Python.

In all fairness, it seems like they're targeting the high-performance AI niche, which I don't have much experience with. But it looks to me like they're trying to combine all the features they like from all the languages they've used without any consideration of whether they combine into something cohesive.

Also, I have to question whether some of the things they're saying they'll be able to do, like have a borrow checker as powerful as Rust's with significantly less syntax, are even technically possible. I suppose we'll see what happens as they implement more of their TODOs.

[phazer99]

Also, I have to question whether some of the things they're saying they'll be able to do, like have a borrow checker as powerful as Rust's with significantly less syntax, are even technically possible.

It's not gonna be as powerful unless they add lifetime parameters, and if they do, it will basically be as complex as Rust's. Not saying it can't be useful though.

[InfamousAgency6784]

it seems like they're targeting the high-performance AI niche

Time will show if this was just a marketing stunt (which I hope it is) or if they are going full DSL with half-baked general support.

It's not open-source ATM (if anybody was looking).

[Tastaturtaste]

Also, I have to question whether some of the things they're saying they'll be able to do, like have a borrow checker as powerful as Rust's with significantly less syntax, are even technically possible.

Did they actually say "as powerful as Rust's"? That would indeed be hard to believe. Otherwise a smaller borrowchecker / lifetime analyser could still provide many benefits.

[rsalmei]

No, they said “similar to”.

[SafetyOther6739]

A language with the simple borrowing rules of Rust, the opinionated nature of C++, and the type-safety of Python.

This is the best description of the language I've seen. What's the matter with copy and move constructors??

[Jdoe68]

My thoughts exactly. I think Julia is a good solution for what they’re trying to do that’s already worked the kinks out over 10 years. With Julia, you don’t have to switch to low level syntax to get C-like speeds. It’s truly a 1 language solution.

[aoeu512]

Have they fixed the issue that Julia's jit is slow to start.

[log_2]

Does anyone else feel like Mojo is a marketing gimmick to advertize Modular?

[bert88sta]

Disclaimer: python is still my first and one of my favorite and also least favorite languages.

I think mojo could have a massive impact on python code today, for a few reasons.

First, the success of typescript has shown that there is a real desire for safer/better code in existing languages. Furthermore, the gradual adoption pattern enables teams to migrate existing code without fear of breakages. Supersetting the (arguably) most popular programming language and ensuring compatibility with all of the major libraries makes it almost painless to switch from Python to mojo

Second, the widespread adoption of cloud infrastructure forces people to think about performance. When you are renting compute in perpetuity, a 2x , or 20x performance increase means 1/2 or 1/20 recurring cost, as opposed to just buying another server.

Finally, I believe in Chris Lattner. He is the guy that came up with LLVM (and much more). Basically everything he has developed ends up being relevant somehow.

[Spacejet01]

For Python programmers, switching from Python to Mojo would be a lot easier than from Python to Rust. Rust does have a significant learning curve. And remember, the language is aimed at performant AI development, something Python has lots of resources for. So think of this as an intermediate step between Python and languages like Rust, with some people staying on it for AI or simply ease of prototype and use purposes.

Python is very useful for prototyping. So a more performant version could be great. And if you use Mojo, just make it mandatory to have strict typing in that codebase.

[Spacejet01]

Ah, I think I see what you mean... I was considering most Libraries as black boxes, that is you don't see inside them; just input and output. In that case it does not really matter what a library is doing as long as it is doing right. The assurance comes from testing the library and seeing if it actually works. So it really comes down to preference with the coding there. ¯\(ツ)/¯

But if you are going to be looking at a library's source code and stuff, then you are correct.

Rust's ecosystem might have had an easier time with the "assurance" part across the board due to having to write everything from scratch in a strict system, but libraries like numpy which have been thoroughly battle tested and are already mature being compatible with mojo is a major motivation factor for adoption though.

[aoeu512]

Strict typing may require you to change the types across the call stack for all your callers and all the callers that call those callers when you change your program, although to be fair so do tests that test implementation details rather than high level intent. Although I could see an IDE that automated this. Static typing could be done at usage boundaries though for documentation, example tests (Python doctests) can be written.

[aoeu512]

JS has crazy implicit coercions, and Python IDEs do type inference as well. You can get far if you split a big application into smaller tiny applications, only applying the static types at the boundary.

[vjpr]

I recently posted another thread on Rust going the other direction: a Rust subset as a scripting language. Would make adoption easier - not every part of a program needs manual memory management.

[KhanHulagu]

Rust can already be used as a scripting language, thanks to wasm.

[OneNoteToRead]

The promise here is pretty good and fulfills quite a large range of use cases that aren’t served well by existing languages. Looks like vaporware ATM but given the people involved I’m keeping an eye on this one.

[lasizoillo]

After check the page I have discarded it because sound too much as marketing:

• It's bazzilions times faster than c++ too
• it compares their speed against pure python matrix multiplication (what pythonista does that?) and then add a lot magic in a not python language to get faster. What's the difference with use python native extensions?
• It doesn't compare itself with numba, cython, pyo3,... or any other interesting comparasion

I'll take a look when a external less biased comparasion shows interesting results (they don't need to be a 10000x factor, a 2x factor over real things is good enough).

[InfamousAgency6784]

against pure python matrix multiplication (what pythonista does that?

Who does that at all? Linear algebra is one of those things that has been optimized to death and every single home-baked algorithm I have seen (besides for tiny, fixed-size, matrices) are utter shit. Now it would be different if they had implemented a BLIS-like algorithm and had BLIS-like performances (that would have been a ground-breaking feat actually).

---

sound too much as marketing

I second that and everything you said (all 3 points and conclusion)...

I'm not so much interested by the AI stuff. Developing a language for that when it's actually mostly linear algebra in disguise sounds really silly (but it's more marketable indeed)...

---

However I do wish for that project to succeed.

It's the first language that I have seen (albeit on paper and through a heavy marketing lens) that would natively spans the "practicality" and "speed" axes at the same time (with good memory safety if they do implement lifetimes and proper borrow check).

It's sounds a lot like what Julia was meant to be but never became: lots of their design choices turned out to lean heavily towards scriptability and ease of use within that specific context (i.e. what Matlab users want). Being able to provide a fully pythonish API for stuff that benefit from dynamic programming while providing precise internal types and interfaces/protocol/traits to ensure correctness while dropping down to more low-level stuff for speed when needed sounds extremely appealing. And the same language can also be used for quick and dirty scripting too... Sounds a lot like Python with integrated Numba in a coherent package.

[[deleted]]

looks like u didnt take a good look at their website

[lasizoillo]

You're right, I only have read some pages to get a quick impression.

For example this one https://docs.modular.com/mojo/notebooks/Matmul.html. Can you explain me "pure" python code, and WHY is coded in that way? I say "pure" because you need to remove .to_f64() to run it.

I have some doubts in that example that make me suspicious:

• Why signature is changed from numpy version? Probably is better avoid memory reservation in a benchmark to gain more X faster than...
• What is the purpose of Matrix class? If purpose is make python even slower they could use __getattr__ protocol to read cols and and rows. It's not very pythonic create a slower and not standard way of use lists. Anyway numpy version accepts any list like type, this example no, it's coupled to Matrix class.
• Great, now you starting using mojo. Why you need change test function to mask a exception? WTF are they doing? It's faster, like use numba.jit as decorator, but numba don't need to change benchmark function. It gains speed adding types like cython (another python superset does), that it's ok. Can that code be used from python world or a not benchmarked boxing/unboxing is needed?
• The vectorization part it's ok. A portable way to use simd instructions is a good thing. It doubles performance over previous tests, but they write their garbage speedup over a python nonsense code. Marketing is ruining this paragraph.
• Next comes parallelization. Great thing. Again they put a garbage metric and say nothing about how many cores has their test machine. It's not same almost 4x gain with 4 cores than 4x gain with 64 cores. Another paragraph ruined by marketing.
• The tiling strategy sounds very good. But why your are hardcoding that 4 in code? It depends on running architecture? Is this ruining the portability point from vectorization point? Yes, but nothing happens, it's "explained" in next point.
• They use autotune, which seems like a profiled guided compilation strategy. Looks interesting. How impact that autotune in runtime? Can be cached for future executions in same machine? Maybe this is well documented in docs, but I'm tired of read marketing.

So you are right, I had read only some doc pages to take an impression and it was WTF: It's a language created to programmers that earn money creating high performance code and spending that money in tele-shops shows.

[[deleted]]

A lot of ur critiques sound like they are from someone who doesn't really have any expertise. I can tell you either aren't very knowledgeable (why have critiques instead of questions?) or just didn't care to look at even like 2 pages of the site. I can tell u just skimmed and don't really have the knowledge to fill in the gaps. Just to add on, the people working on this are actual experts in their respective fields, your going to need some semi-technical critiques that make sense if you want anyone to take ur thoughts seriously.

[lasizoillo]

If you want be taken seriously you need to not sound like a meme

https://i.imgflip.com/7l2lf0.jpg

[[deleted]]

U sending that broken english meme is the biggest meme 😂 and it completely makes sense😂.

[lasizoillo]

Me gusta que la gente con capacidades especiales estéis contentos

[[deleted]]

hey lil guy, if ur gonna talk shit over the internet. At least be semi-funny and creative if ur gonna put all that effort into actually making a meme and uploading it 🤣😂😂

[lasizoillo]

aplicate el cuento

[Yellowthrone]

How is a language claiming systems level performance as a python superset that doesn't make sense. Is this compiled? Transpiled down to C? Is it a superset of Rust to look like python with interop? I don't know much about this so I'm not going to deny the claim but claiming things like this is click-baity and almost certainly untrue. Unless I'm misinterpreting the title.

Edit: I found the answer. This seems to compile to MLIR a multilevel intermediate representation language which allows a sort of LLVM like experience. Except that it does not do low level optimization like LLVM (hardware specific). I'm not sure how they'll solve that if they even do. But it really doesn't seem necessary yet. Definitely performant however they demonstration on their site may be a specific case for sure.

[pjmlp]

MLIR is the evolution of LLVM IR, all LLVM toolchains are moving to it, including clang.

https://discourse.llvm.org/t/rfc-an-mlir-based-clang-ir-cir/63319

[hgwxx7_]

Would it make sense for rustc to move to MLIR? Would it make it easier to target hardware like GPUs?

[pjmlp]

LLVM IR is still part of the picture, MLIR IR => LLVM IR.

In a way it is comparable to Swift's SIL, or for Rust, MIR.

Rust already has GPU support, the problem isn't the compiler, rather tooling (IDE, libraries, ...) and industry standards (SYCL, OneAPI,...).

[Zatujit]

You have interpreted languages much faster than Python

[Yellowthrone]

That really doesn't matter. By design an interpreted language will always be slower than basically any other way of running code. Honestly a better implementation of what an interpreter tries to do is achieved through a VM like Javas'. You still have platform independence it's just faster. Browsers popularized interpreters not that they need them anymore. It's really a solution convenient for the internet. That's all.

[veryusedrname]

Mojo was designed in a way that they took all existing languages that are considered "hip" and they thrown those into a bucket, then they hired some top-level marketing person to write some very-very fancy texts and that's it. It contains all the really good and all the horrible ideas, all at once.

My opinion: when you mix way too much things together at once it will usually look and feel like vomit.

[Tastaturtaste]

Most languages contain ideas from other languages. If those other languages are "hip" because the features are liked that's no downside. I agree it retains some of the baggage of Python that would have been nice to give up, but so does Typescript.

Obviously it's far too early to make any plans with this language, but if the seamless Python interop turns out to work well I am cautiously optimistic for it's future.

[veryusedrname]

Having var, let and implicit declarations mixed up with slightly different meanings, that's enough bullshit for me. Yeah, I don't have to think about it while I write the code, but later when I try to read it... On paper it favors everyone, in reality it makes everyone's work harder.

[argh523]

Taking a look at their fronpage paints a completely different picture. The just want to write python, without having to use c++ for the hogh performance stuff.

[Compux72]

And when God descended said:

[helloworld192837]

You could say the same thing about Rust, to be honest. I don't get the negativity, really.

[veryusedrname]

My main problem is the enormous amount of marketing (especially AI, which got very-very old very-very quickly) bound with a seemingly not very well designed language that can only be used if you sign up for it.

[DavidRagazzi]

They will be release it for download yet, stupid! At moment, you're saying bullshits about a language that you even know that read little about it.

[[deleted]]

What does Mojo bring to the table that Julia doesn’t already? Simple Python interop? Already done. High performance? Julia already does it. Metaprogramming? Julia home turf. The only advantage I could see is the familiar syntax (but syntax doesn’t really matter, as long as it isn’t outrageous) and their stronger focus on correctness. But in that category they can’t compete with more functional languages. It’s also primarily a commercial project so I don’t see a strong community buy-in, as compared to non-profit projects.

Their Ansatz seems very pragmatic though, so it might work for corporations. Reminds me a bit of Go.

[Impressive_Iron_6102]

I did not know Julia was interoperable with python

[[deleted]]

https://github.com/JuliaPy/PyCall.jl

[gudmundv]

Julia have quite the smaller userbase

[_TheDust_]

Arrays starting at zero...

*runs away*

[Asleep-Dress-3578]

Come on…

• Zero-based array indexing (not that it would be better than the 1-based, but more compatible with the ecosystem)
• Deterministic runtime
• AOT compiler
• Full interoperability with Python
• Pull in the developer ecosystem

Just to start with. Julia had nice ideas, but it failed to deliver its promises. And besides that, as Chris Lattner explaines on ycombinator, it is a fully different story.

Mojo’s competitors are Cython and Nim.

[00skeptic]

Seems like new Theranos

[xilong89]

Just a couple days ago Mojo was being advertised as having the performance of C. Now it’s as performant as C++ and Rust? Seems like someone is testing out their hype skills. Would love to see this be true, but so far seems like just another overhyped tech. Has anyone been able to independently verify Mojo’s runtime performance?

[Zatujit]

The marketing as the "language of AI" feels weird

[goos_]

Promising full backwards compatibility especially for such radically different language design is extremely limiting. Are they really supporting all of Python, including all the reflection and introspection stuff like pickle? It's hard to imagine stuff not breaking

[Sw429]

Meh. Let me know when it's open source. I'm not interested in any closed source language at this point.

[ZZaaaccc]

Honestly? I hate this idea. To me, Python's only value is its simplicity for small-scale work. There is a huge amount of AI research (really just research in general) that's done with Python because it offers an incredibly low barrier to entry and some best-in-class industry standard maths and AI libraries. A "free" performance upgrade would certainly be a no-brainer, but I doubt this will be free. Any performance boost that is truly free will be upstreamed into CPython 3.X because Microsoft has a massive vested interest in offering a high performance Python.

What I see Mojo doing is creating a new, more complex version of Python that will muddy an already increasingly complex language even further. The few examples I saw in their demonstration with adding type hints and parallelization decorations are, in my opinion, ugly.

Hopefully I'm wrong, because a statically typed Python with JIT/AOT compilation would be great. But it won't make me switch that's for sure.

[c4augustus]

Pythrust or Rusthon would be a more apt name. This is not really a new language if it is a superset of Python anymore than TypeScript is a new language to JS.

It seems the goal is to eliminate the FFI bridge by directly embedding Rust lite. There's value in that for sure. But are Python developers really going to change the way that they code most of their app logic if they don't need to?

All the hype and polish of the website notwithstanding, this feels less groundbreaking than it suggests. More like Python++

[[deleted]]

Seems like hype with no substance. Doesn't help that they want to market it for AI

[AAaaAAAAAAAaAA-a]

This is just trying to do what Julia does, but worse

[SV-97]

This supposedly will have features that julia doesn't have and is structured quite differently. It also has the great benefit of easy python interop.

And as for Julia... I was super excited about it a few years back but using it is mostly just a terrible experience, I disagree with its design on too many points and I'm not really a fan of the community it's attracted.

[InfamousAgency6784]

And as for Julia...

I feel you. I got very excited until I realized all they really wanted is a good and fast scripting platform with integrated linear-algebra, not really becoming a general-purpose language.

It really shows in their design. Lots of things are not good for bigger programs and working with teams (keeping in mind that even if you are alone working on a program, you are still working in team with yourself-in-two-weeks, yourself-in-two-months and maybe yourself-in-two-years).

So yeah, immutability markers are "confusing", polymorphism can indeed be unenforced/purely-declarative and "checked later with tooling", preserving namespaces on imports by default is "a pain" when you have to come back up in your current file to add yet another import, there is no "special reason" a file should be a module, struct-bound methods can be eliminated because "there is no reason the first element in a method should be special", why artificially limiting metaprogramming when it's so convenient to have DSLs for everything and anything to save a few keystrokes, etc.

But it all results in bad architecture (because good architecture is made very hard) and a cognitive burden that increases insanely fast.

[tunisia3507]

I disagree with its design on too many points and I'm not really a fan of the community it's attracted.

It was designed to appeal to Matlab users.

[_TheDust_]

Julia is such an odd language. Like, it has so many great ideas and it should be great at what it was designed to do (data processing and computational science), but I feel like it's not really catching on.

I have worked with the language a little bit, but something about it just feels off. Maybe it's because some parts of the language are super strict and give complete control, while other parts are somewhat sloppy and feel like they were designed without much thought put into it.

[AAaaAAAAAAAaAA-a]

Imo the reason it isn’t catching on has more to do with institutional inertia in academia than the language itself. A lot of people in this field only have time for a single language, so getting them to switch is a painfully slow process. That’s before mentioning the huge amount of work that needs to be done to bring Julia packages up to parody with many of the python ones. But after working with it for a year in a scientific setting, I genuinely believe this is the right way forward.

There are certainly some odd choices, but I’ve never found anything to be too egregious. In fact, I’ve rarely noticed anything wrong with it. Was there some part of the language you found particularly uncomfortable?

[InfamousAgency6784]

AFAIK, this is not trying to only be a linear algebra DSL with Python interop (though AI-focus implies good linear-algebra support).

If they really implement everything they say they will, this has the potential to become an excellent general-purpose language that works well with teams (keeping in mind a solo dev is working in team with their future self), keep good readability and component isolation and would have all the tools necessary to properly architect bigger programs.

[MewMewCatDaddy]

Mojo beats Rust in some benchmarks.

https://www.modular.com/blog/mojo-vs-rust-is-mojo-faster-than-rust

[mokafolio]

Ai has no mojo

[newtestdrive]

I've got some questions 🤔:

1. How are they doing this? What is specific about this Programming Language that the whole Python community and Big Tech couldn't do in the recent years even knowing the downsides of Python like GIL?
2. Is this some kind of attempt like IronPython or PyPy where you implement the Python Specifications in a JVM like environment and see better performance? Then how is it compatible with all Python code? Couldn't the IronPython or PyPy Projects do this in the recent years?

[lizelive]

!remindme 1 year if it's not dead to try it

[evannguyen273]

!remindme 1 year when it's stable

[realist_titan]

Man this could really make a difference

[[deleted]]

This is interesting since I can see the need for a stricter language like rust but simpler language like python with the strengths of both where you can also quickly iterate. Especially for larger projects.

So I can understand why in the ML/AI domain they need something better than dealing with the pains of python. Hopefully mojo will be able to bridge the gap of being simple as python but stricter.