Hacker News Reader

Comment by deterministic | Hacker News Reader

And the result is that most new open source languages (and commercial companies) use LLVM instead of GCC as the backend => way more engineering resources are dedicated to LLVM.

View on HN

For what it's worth, the leverage did work, just not forever. It was a play with a limited lifetime. It didn't necessarily need to shake out that way, probably if GCC was slightly easier to write for but not too easy people would have invested more. It took a major investment to create a competing product.

I thought GPLv3 adoption by GCC was what really lit the flames on moving to llvm by commercial entities?

you only need to worry about GPLv3 if you are modifying gcc in source and building it and distributing that. Just running gcc does not create a GPLv3 infection. And glibc et al are library licensed so they don't infect what you build either, most especially if you are not modifying its source and rebuilding it.

And what we've seen from e.g. Apple is that "make a private fork and only distribute binaries" is exactly what they wanted the whole time.

you only need to worry about GPLv3 if you are modifying gcc in source and building it and distributing that.

That's the context here. If you build a new compiler based on GCC, GPL applies to you. If you build a new compiler based on LLVM it doesn't.

the context here doesn't actually specify whether we are talking about companies using llvm sources to create proprietary compilers (or maybe integrated with a proprietary IDE) or using llvm to quickly bootstrap and craft a compiler for a new processor, new language, etc., where they will distribute the source to the compiler anyway

but such a compiler or IDE would not GPLv3 infect it's users' target sources and binaries.

The main problem with GPLv3 specifically from the perspective of various commercial vendors is the patent clause.

Still some companies try hard to avoid GPLv3, see Apple, who either provide old GPLv2 licensed software or invest in BSD/MIT replacements.

You might know this history better than me.

GCC has come a long way in terms of features and complexity since the 90's/00's when Stallman made these decisions. Today, building a compiler from scratch would be a huge undertaking, and would be prohibitively expensive for most organizations regardless of licensing.

If the requirement was still just to implement a "simple" C89 compliant compiler, and I was worried about software freedom. The GPL is probably still a good bet.

I'm not sure that's the only reason. In recent years a lot of projects have chosen to avoid the (l)GPL and use more permissive licences to try and reach a larger audience that might have been spooked by free software.

This gave LLM a leg up too.

They can do this because they have a choice. Apple cleaned itself of the GPL once it could, after a long stint where it couldn't. Had GCC been the library backend standard instead of LLVM, the world would have a lot more GPL in its compilers.

> They can do this because they have a choice. Apple cleaned itself of the GPL once it could, after a long stint where it couldn't. Had GCC been the library backend standard instead of LLVM, the world would have a lot more GPL in its compilers.

I don't think this is a valid assumption. If the root cause was a refusal to adopt GPL software, I think it's rather obvious that in a universe where LLVM doesn't exist, companies such as Apple will still diverte their resources to non-LLVM software.

Apple is also not resource-constrained or a stranger to develop compilers and their programming languages. Does anyone believe that GCC is the only conceivable way of developing a compiler?

There's a lot of specious reasoning involved in this idea that LLVM is the sole reason some companies don't adopt GCC. The truth of the matter is that licenses do matter, and if a license is compatible with their goals then companies can and will contribute (LLVM) whereas if it isn't (GCC) companies will avoid even looking at it.

And yet, LLVM is thriving, and not desolately crying for proprietary commercial improvements to be fed back by their creators. It's an odd balance, sometimes it works out, this seems to be such a case.

Let's be real here.

A lot of this is driven by FAANG or FAANG wannabes, companies at a scale where they can basically reproduce huge chunk of OSS infrastructure.

They also put out a lot of Open Source with they don't want to license as GPL due to a general fear of GPL contamination.

Most of this is huge corporation driven.

There is also the case of the more liberally licensed SRC Modula-3 compiler (front end) which worked around the GPL by running GCC as a separate process and feeding it IR files. Less efficient, but effective.

It's always an option if you're willing to put up with the awkwardness and inefficiency. GPL has more in common with DRM than you would think.

In retrospective, I think this came out for the better in case of LLVM, and probably for GCC too. After all, both compilers emit ~equally optimized code today.

More languages choose LLVM as their primary backend, like Rust, Crystal, Julia.

Reply on news.ycombinator.com