melodyogonna

Related post with relevant pr: https://news.ycombinator.com/item?id=49347777

I don't use Cursor, I use Grok.

Grok has started competing with frontier models on coding thanks to Cursor's data, with SpaceX's massive compute they can undercut competition on price, which makes the offering real appealing.

I've now switched to Grok 4.6, I was previously using Opus 4.8 but Grok is good enough now, and way cheaper which is the important part.

Not really the point of the post, but there is a third memory allocation paradigm where you can do manual allocations and deallocations, but without the mental overhead of having to remember to free memory because the compiler will force you to properly handle it. Mojo has linear type support so you can do something like this: https://x.com/melodyogonna/status/2085089269484343725?s=20

The point is that you can compile both old and new versions of C++ using the same compiler. Rust and Go also evolve like this

Here is a presentation talking about the parallelization techniques, I skipped to the relevant part but the entire presentation is helpful in understanding how Mojo's compiler works: https://youtu.be/yuSBEXkjfEA?t=813&si=MlB7IsBDsj3o-PTX

Well, LLVM itself is still single-threaded; they just designed Mojo's compiler in such a way that the code generation part can be parallelised, which is something you can do if you understand LLVM from top to bottom. As far as I can see, no other production-grade LLVM consumer has been able to make it parallel; the single-threaded nature remains a major performance bottleneck.

They're an AI company

The novelty is in parrelizing LLVM, which is traditionally a single-thread code generator.

Mojo compiles with O2 by default, it is similar to Go here. Release build is the default, debug is something you opt into. It is still very fast nonetheless

Mojo is much faster than Rust, but slower than Go. I don't have much experience with Zig.

Mojo is designed to be very fast to compile, so many decisions were made to keep the core language simple, one example is in `where` clause, the checking there happens entirely in the parser. It can be stupid in situations where other languages are smart, and make you explicitly do checks that could be inferred in other languages. But on the other hand, it can be very fast since it doesn't have to do all the complicated resolving.

Another reason is how LLVM is used, Modular found ways to parralize LLVM code generation by introducing novel techniques that'll likely become a lot more popular with other languages.

My guess is that the compiler will be opened next week at Modcon. Honestly? I'm surprised Mojo 1.0 is being released now; I had thought it would be released at Modcon along with the compiler source code, but oh well, 18th August isn't far now.

When I use AI with Go I give it this rule:

Prefer standard Go libraries and tools.

80% of the time I can get by without external dependencies (outside of Go's X repository)

Isn't Netflix a Java shop

Hurray!

Very interesting. But GPU programming gets complicated when you start doing 3d computation on very large data, will be interesting to see how tensor abstraction is built on top of this. Another point is that this is using fixed-width SIMD vectors; unless there is a way to compute this statically based on available GPU info, performance will always be left on the table.

Oh wow, that's a blow to Google, what's with the talent scarcity in ML. Though if this goes anywhere Google will likely buy them back.

Is there a particular reason why they're looking for Github stars?

Linear types requires significant work to incorporate into the core built-in collections and types. I've been following the work on Mojo to enable Linear type support for built-in types and collections, I don't think Rust's language semantics will allow for the same level of integration (Rust is already stable).

To what? What would you use instead, things like this seem common place in languages made in the last decade.

Many people find it complicated.

They're using Go, Swift, and Zig: https://x.com/mitchellh/status/2082623830510710865?s=20

These AI companies needs to stop with all the doom and gloom.

Django is nice, but I'm currently migrating a project from Django to Go because Django is too large. I would love to stay with it, but simply assimilating the docs has been a chore. The PDF is 3000 pages, and I love working with tools where all the parts can fit in my head.

Because I prefer Chrome.

I did not know Theo had such influence on companies.

Oh this seems very useful, I hope we'll get it on Chrome sometime. At the moment I have to use profiles to achieve the same thing

You can depend on just MLIR core; Mojo (from Modular) uses MLIR, with only the index and LLVM dialects coming from upstream MLIR. The benefit is that you focus on designing your IR without also building supporting infrastructure, while having MLIR ecosystem at hand should you need it.

Why not just use MLIR?

I disliked OpenCode's LSP integration, as Pyright kept distracting the model from what I wanted done in a Django project. I prefer to run MyPy at my own convenience