HNHacker News
TopNewBestAskShowJobs

melodyogonna

818 karma · joined August 31, 2021

submissionscomments
melodyogonna··on Mojo 1.0 Beta
> In effect, they are completely different hardware. The only thing any of them have in common is rasterization primitives

They can also do matrix multiplication, which is the relevant thing here.

Mojo is not an OpenCL-style library; it is a programming language, and it doesn't really abstract much. However, it is designed to support compilation to exotic hardware. Cuda CPP can also be thought of as a language; however, the compilation model and core primitives are fundamentally tied to Nvidia hardware.

> Like what? None of this is a rhetorical question, explain to me what information would help bring GPUs and TPUs up to parity with CUDA.

One primitive would be a data/memory abstraction libary like CuTe but for more than Nvidia: https://mojolang.org/nightly/docs/layout/

Another is a programming model that allows you to specialise based on hardware and hardware capabilities: - https://github.com/modular/modular/blob/c71933db1b22b6a91749... - https://github.com/modular/modular/blob/c71933db1b22b6a91749...

And finally, a novel compilation model that knows how to compile and link code for esoceteric hardwares: - https://www.youtube.com/watch?v=77Z_kngHs00

melodyogonna··on Mojo 1.0 Beta
I don't recall they promised that. They promised it'll be a superset, but Mojo introduces new keyword. Mojo could support all Python features today exactly as they're supported in Python and you wouldn't still be able to copy Python code into Mojo and compile it
melodyogonna··on Mojo 1.0 Beta
> Why should they? CUDA is a GPGPU paradigm, AMD/Apple/Intel all ship diverse raster-focused hardware, and TPUs are a systolic array. How much can you realistically expect to abstract with unified primitives?

Ah, it seems impossible to you. These are very different hardwares... It is hard enough to make compatibility among different hardwares of the same vendor. Very difficult to imagine building primitives for hardwares with completely different memory layouts.

> How much performance do you perceive to be left on the table with native CUDA-based implimentations?

Zero is the idea. And I wasn't saying there should be a native cuda-based implementation, I'm asking you to imagine how much easier everything would have been if Cuda was cross-platform without any performance or ergonomic penalties.

Mojo is a foundational step here. The big HOW is powerful parametric programming. So much information could be passed during compile time which the compiler uses to specialize.

melodyogonna··on Mojo 1.0 Beta
It was always going to be a long-term thing, if it were even possible. You can't make a compiler that can compile Python into efficient machine code in just a year (which was how long Mojo had been in development when it was announced).

The messaging was changed because people got sold too hard on that, and kept trying Mojo with the expectation that it could compile existing Python code when it couldn't. What Modular did was change the messaging to reflect what Mojo is today, and provide a roadmap[1] of what they hope it'll turn into in the future. As it evolves, the messaging will evolve with it to continue reflecting current capabilities.

1. https://mojolang.org/docs/roadmap/

melodyogonna··on Mojo 1.0 Beta
Have you ever wondered how much work would have been saved by the Pytorch team if they could have used just Cuda for all the platforms they support? If they didn't have to write compatibility abstractions or layers, and instead just focused on the problem of training neural networks? What if all the primitives they used from Cuda and cuDNN worked just as well on AMD GPUs, Apple GPUs, and probably Google's TPUs as they did on Nvidia GPUs?

Mojo and Modular's Max platform would do to heterogeneous compute what LLVM did to programming language development. People who dismiss the real value offering here know nothing. Modular have already raised $350m+ from industry giants (including Nvidia and Google) to solve this, and I believe they will.

melodyogonna··on Mojo 1.0 Beta
Something like this https://github.com/tairov/llama2.mojo?
melodyogonna··on Mojo 1.0 Beta
Mojo isn't that far away from 1.0. Some point this year is the target
melodyogonna··on Mojo 1.0 Beta
Pytorch is built on an amalgamation of these different frameworks, not on one of them used to target different vendors.
melodyogonna··on Mojo 1.0 Beta
It is portable in that you can write code to target multiple platforms in the same codebase. Mojo has powerful compile-time metaprogramming that allows you to tell the compiler how to specialise using a compile-time conditional, e.g. https://github.com/modular/modular/blob/9b9fc007378f16148cfa...

Of course, this won't be necessary in most cases if you're building on top of abstractions provided by Modular.

You don't get this choice using vendor-specific libraries; you're locked into this or that.

melodyogonna··on Mojo 1.0 Beta
https://mojolang.org/docs/tools/skills/
melodyogonna··on Mojo 1.0 Beta
You'd be surprised. Anyway, the compiler will be opened with 1.0 release, that's why reaching beta is exciting.
melodyogonna··on Mojo 1.0 Beta
People keep mistaking Mojo as good syntax for writing GPU code, and so imagine Nvidia's Python frameworks already do that. But... would CuTile work on AMD GPUs and Apple Silicon? Whatever Nvidia does will still have vendor lock-in.
melodyogonna··on Talking to strangers at the gym
Ha! Nerds.
melodyogonna··on Bugs Rust won't catch
TL;DR: Rust can't catch logic bugs
melodyogonna··on Sky – an Elm-inspired language that compiles to Go
Aha! That would explain things. I was wondering if the Go assembly at least is stable and documented, couldn't really find anything
melodyogonna··on Sky – an Elm-inspired language that compiles to Go
https://lisette.run/
melodyogonna··on Sky – an Elm-inspired language that compiles to Go
That's two new languages compiling to Go making HN frontpage in as many days. It seems people like everything about Go except the language itself. Me? I like everything about Go including the language, these transpiled languages are interesting though.

But I keep wondering if they could integrate at a lower-level than the source code. Like how JVM languages integrate at the bytecode level, or LLVM languages at the LLVM level

melodyogonna··on Lisette a little language inspired by Rust that compiles to Go
Python has a performance problem. Most people may not need it, but many people do. Languages like Rust and Go are heavily adopted by Python programmers either trying to understand low-level concepts or looking for something more performant.

And this is before we talk about the real selling point, which is enabling portable heterogenous compute.

melodyogonna··on Lisette a little language inspired by Rust that compiles to Go
It does matter. It already has a pretty active community and thousands of people who follow the development closely, however, most won't commit until the entire language is fully opened... including me.

Valuable technologies are not so easily dismissed

melodyogonna··on Lisette a little language inspired by Rust that compiles to Go
The compiler will be open-sourced in a few months.
melodyogonna··on Lisette a little language inspired by Rust that compiles to Go
That is interesting, but I imagine Rust has features which can not be translated into Go's assembly. This language is specifically designed for Go interop; the logistics wouldn't be the same, though I still expect it to be difficult.
melodyogonna··on Lisette a little language inspired by Rust that compiles to Go
I'm wondering about the logistics of making this integrate with Go at the assembly/object file level rather than at source code level. What if it compiled to Go's assembly rather than to Go source code
melodyogonna··on Google releases Gemma 4 open models
I reviewed the TensorRT-LLM commit history from the past few days and couldn't find any updates regarding Gemma 4 support. By contrast, here is the reference for MAX:https://github.com/modular/modular/commit/57728b23befed8f3b4...
melodyogonna··on Understanding the Go Runtime: The Scheduler
How so?
melodyogonna··on Understanding the Go Runtime: The Scheduler
> If you have a system that requires predictable latency, go is not the right language for it.

Having a garbage collector already make this the case, it is a known trade off.

melodyogonna··on Zig – Type Resolution Redesign and Language Changes
Rust started in 2006 and reached v1 in 2015, that's 9 years.
melodyogonna··on Undo in Vi and Its Successors
I can not imagine coding without multi-level undo.
melodyogonna··on Zig – io_uring and Grand Central Dispatch std.Io implementations landed
But Zig's async is being designed to enable this low-level control.
melodyogonna··on GitHub is down again
I think this will continue to happen until they finish migrating to Azure
melodyogonna··on I miss thinking hard
I use Aider because it allows me to retain both personalities and still benefit from AI. It truly is the best assistant I've used.
← PreviousPage 4 of 12Next →