Modular Blog

> but I don't see it being used for any practical applications The industry only cares about one thing: ability to market and sell as a means to make money. Ideally a compiler translates human-understandable code into the fastest possible machine-understandable code. Every tech company is essentially a compiler company because they need people to extract the most performance from their software and hardware. There are a gazillion AI companies nowadays, they all need training or inference to go faster, they all need compiler people. Lattner [0] knows this, and that's why he started Modular AI [1]. If you want attribute grammars to be involved, you need to make them solve this problem better. That's your task. That's the value you bring. How do you do this? Here are links to items posted over just the last few weeks on HN. Karpathy spells out neural networks [2], so understand the computational problem. Nvidia describes the difference between CPUs and GPUs [3], so understand the spectrum of computational fabrics. Now figure out how to best solve this computational problem given the different fabrics and their differing trade-offs. Easy. [0] https://en.wikipedia.org/wiki/Chris_Lattner [1] https://www.modular.com/ [2] https://news.ycombinator.com/item?id=32491440 [3] https://news.ycombinator.com/item?id=32053502

Feel like Mojo is worth a shoutout in this context https://www.modular.com/mojo Solves the issue of having a superset of Python in syntax where "fn" instead of "def" functions are assumed static typed and compilable with Numba style optimisations.

LLVM people have been at it for a while now, they got it working on Nvidia and AMD working on apple I believe: https://www.modular.com/ it baffles me that more people haven't heard about them. it's mighty impressive what they have achieved.

This is the best article on why OpenCL failed: https://www.modular.com/blog/democratizing-ai-compute-part-5-what-abou…

Lattner left Apple a long while ago. He's been working on Mojo, a different (Pythonic) language and runtime: https://www.modular.com

Mojo from Modular? I've not checked it out enough yet, and it's early days for it anyway. Just saying it may be worth keeping an eye on. I've seen some videos of Chris Lattner talking about it. https://www.modular.com/mojo https://hn.algolia.com/?q=mojo

Very true, it isn’t usually the best designed language that wins in these cases. The language just needs to be good enough like CPP and JS were. Python is nicer to write than either and with [mojo](https://www.modular.com/mojo) possibly rising in popularity, Julia will lose some of its benefits. The momentum is behind Python which is the ultimate factor.

The other big part of this press release is the local availability of Mojo: We are also excited to announce the next major step forward for Mojo – the ability to download Mojo and a whole developer toolset locally to your desktop machine. The ability to run Mojo locally is the most requested feature from Mojo developers so far and will lead to increased innovation and collaboration in the Mojo developer ecosystem. We are shipping a preview of the Mojo SDK to hundreds of early adopters today, and we will release it generally to everyone in early September. Sign up to download [0]. [0] https://www.modular.com/

Mojo seems like a very promising solution, despite it being AI oriented. Lex Friedman had a great podcast with the founder, its first version was released about a month ago, and in two weeks got 10k discord users. A superset of python that, once finished, can run all native python code, but also adds language features to get closer to the “metal”, getting speeds of C libraries with the ability to properly debug and step through it. If this project goes the way it’s promised (the guy has great experience with language development), this could further cement python as it would solve its biggest criticisms. Very excited for it https://youtu.be/pdJQ8iVTwj8 https://www.modular.com/mojo https://en.m.wikipedia.org/wiki/Chris_Lattner

I suggest AI people to look into Mojo[1]. They are building a language that is fully compatible with python, but when performance is needed it can become typed and compiled. Its very early days, but that seems to be best way to depythonize [1] https://www.modular.com/mojo

And of course, Chris Lattner’s Modular AI https://www.modular.com/

I’ve said it before and I’ll say it again: Rust feels like a Python developer’s idea of a high-performance computing language. It’s a great language for many kinds of applications — just not when you need to squeeze out every bit of performance from advanced hardware. Even before getting into SIMD, try using Rust for concurrent, succinct, or external-memory data structures. It quickly becomes clear where the friction is. Cargo is fantastic — clean, ergonomic, and a joy compared to many toolchains. But it’s much easier to keep things simple when you don’t have to support dozens of AVX-512 variants, AMX, SME, different CUDA generations, ROCm, or any of the other modern hardware capabilities. Standardising SIMD in the standard library — in Rust or C++ — has always been a questionable idea. Most of these APIs cater to operations that compilers already auto-vectorize reasonably well, and they barely touch the recent capabilities of SIMD. Just consider how hard it is to build any meaningful abstraction over the predicate/register models across AVX-512, SVE, and RVV. RVV aside, this should illustrate the point: https://www.modular.com/blog/understanding-simd-infinite-complexity-of…

Mojo feels like a great fit for so many domains outside of AI. It could be a killer general purpose language. It's easy to read and write, offers memory safety without RC or GC or even much mental overhead, will (eventually) be a superset of Python, and it's very performant already. So far I've been hesitant to invest more time in it when it's pitched as "the programming language for all AI developers", when it's distributed inside the MAX package[1], and when Modular is prioritising features around AI over all else. (I understand why for all these things, I just wish it were otherwise.) It's great to see the library in the open, but it would be much more compelling for me if Mojo were a separate entity, with its own open site and foundation, to be used by Modular but with more diverse adoption encouraged. Of course it's early days, but I hope it takes on a life more like Rust than Swift (which — despite its potential as a general-purpose language‚ is still largely used in one ecosystem). 1: https://www.modular.com/blog/max-is-here-what-does-that-mean-for-mojo

I guess they could have implemented some of the flags as aliases or rather bash functions to a preset chain of invocations. The merging of flags would be difficult though. There are many flags that change the behavior of the file system calls that would be made...such as getting additional information. To support all the formatting commands, the piped output of `ls` would need to be very verbose and structured too...like json or something. They had to draw boundaries of functionality at some point. So the unix idea of "one thing" was probably defined a bit more vaguely or more end-user use case related. Convenience seemed to be king. It would have be nicer if they could have added a shell-like pipe syntax to C (and designed the code in a more modular and stream-like way). In the `ls` [source code][1] you can see simple blocks of steps like: if (!file_ignored(file)) { ... sort_files (); print_current_files (); clear_files (); } For example the `file_ignored` function in `ls` would have made a nice reusable library (with standardized configuration params) and a cli tool (with standardized flags). Missed opportunity to unify the shell and C, but I guess SmallTalk was kicking around at that time which went a whole lot further. It's funny that we are still very much lacking this unification... We don't have a high-level interpreted language that can also perform well as a system's language. New systems languages are popping up all…

I think this is a name collision https://mojo.ai/. Any have information on this beyond a screenshot? This looks related https://www.modular.com/ (currently claims to be playing a "2023 product keynote", but doesn't seem to be doing so). edit: now seems to be fixed, https://docs.modular.com/mojo/ > With Mojo, you can write portable code that’s faster than C and seamlessly inter-op with the Python ecosystem. Doubtful. Still reading the docs, but noting > We don’t want to rely on fancy tricks (like JIT compilers) to make things faster Reached end of docs. I'm sold. - Compile time language is ~ the runtime one. That's the model most systems languages seem to have ended up at. It doesn't have macros or reflection, but neither of those seem to be very popular - The struct/let notation and lifetime model essentially give you C++ semantics with saner syntax. The class/def notation essentially give you python semantics. This is a clean answer to the gradual-typing-for-performance problem - You can drop into MLIR at will and the std types are implemented like that. This makes the language look a lot like syntactic sugar over writing the IR which closely matches how (at least some) compiler devs think about programming languages Yeah, I think that'll work. Python/C++ mashup is a popular dev stack and this can make that much cleaner. Faster than C is rather unproven but given the difference in compile time control should be achievable.

The actual blog post on open-sourcing: https://www.modular.com/blog/mojo-open-source I remember being really interested a few years ago when it was billed as a superset of Python. I know they pivoted away from that, but I might play with it now that the compiler is also open source.

> On the grand scale of things, Windows is the niche platform here. They plan Windows support: ” Mojo has supported macOS and Linux for years, and Windows developers have been able to use it through WSL. Native Windows support has always been one of our most common requests from developers. Millions of developers build on Windows every day, across an enormous range of applications and workloads. We believe Mojo can have a meaningful impact across that ecosystem. Bringing Mojo to Windows the right way requires deep expertise in the platform, which is why we’re delighted that the Microsoft Windows team sees the same opportunity we do — and that we’re working together to make it happen.” —- https://www.modular.com/blog/modcon-announcements

That's quite promising - https://www.modular.com/blog/modcon-announcements#:~:text=Windows%20su…

This page really helped me to put it into perspective against Python: https://www.modular.com/blog/an-easy-introduction-to-mojo-for-python-p…

It's kind of funny that Modular is getting acquired by a hardware company considering what it's founder has said repeatedly in interviews and articles about how those companies fail to make AI stacks. * https://www.modular.com/blog/democratizing-ai-compute-part-9-why-do-hw…

I wish you guys could partner with Modular to get Mojo inference working on your hardware, e.g. https://www.modular.com/models/deepseek-v4-pro

Modular is going to open source the entire mojo SDK later this year, including the compiler. > Mojo 1.0 will be finalized later this year, along with opening the compiler and providing language stability. https://www.modular.com/blog/modular-26-3-mojo-1-0-beta-max-video-gen-…

Mojo is a language with Pythonic syntax that compiles to fast machine code built by the creator of Swift: https://www.modular.com/open-source/mojo

Thanks for the notes, for those interested in learning more: - Lattner tweeted a link to this: https://www.modular.com/blog/day-zero-launch-fastest-performance-for-g… - Unsloth prior post on gemma 3 finetuning: https://unsloth.ai/blog/gemma3

If you want the fastest open source implementation on Blackwell and AMD MI355, check out Modular's MAX nightly. You can pip install it super fast, check it out here: https://www.modular.com/blog/day-zero-launch-fastest-performance-for-g… -Chris Lattner (yes, affiliated with Modular :-)

> The central view of ape coding proponents was that software engineered by AIs did not match the reliability of software engineered by humans That's not the reason to do ape coding. AI generated code is innovative. If you want to build something that no one has built anything similar to then you have to ape code. See Chris Lattner's blog where he explains the limitations of AI: https://www.modular.com/blog/the-claude-c-compiler-what-it-reveals-abo…

Links to his blog post which is at https://news.ycombinator.com/item?id=47074505 https://www.modular.com/blog/the-claude-c-compiler-what-it-reveals-abo…

Most of the stuff you pointed out is addressed in a series of blog posts by Lattner : https://www.modular.com/democratizing-ai-compute

Cuda is 20 years old and it shows. Time for a new language that fixes the 20 years of rough edges. The Guy (Lattner) who made LLVM is working on this: https://www.modular.com/mojo Good podcast on him: https://newsletter.pragmaticengineer.com/p/from-swift-to-mojo-and-high…

There's a higher level of abstraction https://www.modular.com/mojo