For instance, the Rust compiler may be nonfree, because the trademark conditions forbid selling copies or distributing modified versions, unless you fully remove all uses of the trademark . Just what that requires in practice is not clear.
I am just curious about other's thoughts on the remark.
Also, I wonder whether this technically makes all rustc-compiled code non-free software (in the fsf sense.)
Obviously not. FSF considers it acceptable to compile programs with nonfree compilers and even GPL includes special provisions for that. They still consider it a problem, but their solution is gccrs.
[EDIT] That was about rustc, itself.: Maybe. You would need to ask FSF. But most likely yes, they would consider it nonfree.
It's answered in that same article, later: We designed GNU GPL version 3 to prohibit this practice; too bad Linux did not adopt it.
So FSF laments the fact that Linus didn't want to adopt their jihad… but they don't put their money where their mouth is: GNU libc is still under LGPL v2… why? Because they know no one would want to adopt LGPL v3 version, there would be fork and FSF would lose what little influence it still retain… why Linux should commit that suicide that FSF refuses to perform, then?
At some point you would have to accept the fact that this article, while profound and interesting, highlights choices that most Open Source developers do consciously.
It's less that “Open Source misses the point” than “Open Source is more of what people expected from Free Software from the day one”.
Very-very-very few people joined Free Software movement for the jihad against proprietary software that FSF started. Most simply wanted to have sources and we shouldn't forget that even most prominent FSFs tools were always developed by people who haven't shared Free Software movement ideals (Cygnus Solutions was founded in 1989!).
But yeah, the fact that RMS picked up Rust as an example is consistent with his analysis of the LPPL-1.2, e.g.:
This license contains complex and annoying restrictions on how to publish a modified version, including one requirement that falls just barely on the good side of the line of what is acceptable: that any modified file must have a new name.
The reason this requirement is acceptable for LaTeX is that TeX has a facility to allow you to map file names, to specify “use file bar when file foo is requested”. With this facility, the requirement is merely annoying; without the facility, the same requirement would be a serious obstacle, and we would have to conclude it makes the program nonfree.
That wording was there for decades, it's not something FSF invented on the spot. They consider Firefox nonfree, for the exact same reason.
As far as I can see, The FSF doesn’t care about binaries and how they’re been assembled – the point is source (or object in the case of LGPL) availability so you can at least in theory build your own binary. By manually translating if needed. An individual binary cannot be considered free or non-free; copyright doesn’t apply to individual copies separately. It’s about the work.
This is clarified in the GPL FAQ:
Which programs you used to edit the source code, or to compile it, or study it, or record it, usually makes no difference for issues concerning the licensing of that source code.
However, if you link nonfree libraries with the source code, that would be an issue you need to deal with. It does not preclude releasing the source code under the GPL, but if the libraries don't fit under the “system library” exception, you should affix an explicit notice giving permission to link your program with them. The FAQ entry about using GPL-incompatible libraries provides more information about how to do that.
The Rust standard library can be either MIT or Apache 2.0, and if I'm not wrong, both are compatible with GPL (but once GPL...).
"Free software" has always been an awkward choice of words, but sadly it stuck despite a few attempts to fix that.
I think Stallman did something great, but preaching that open-source software is not good enough and proprietary software is bad seems too idealist for me. It must have its roots in history, when companies like Microsoft were taking free or open-source code, modified it a little to make the two versions incompatible and made it proprietary to discard the free version and gain an advantage, but the world has evolved a lot since then, bringing all sorts of business practices, and not all are detrimental to the software community. I feel the GPL is too restrictive for many companies, which prefer to avoid it because of the constraints; a known example is Sony choosing FreeBSD over Linux for its consoles.
The GNU Manifesto includes Why I Must Write GNU section that examples the reasoning:
I consider that the Golden Rule requires that if I like a program I must share it with other people who like it. Software sellers want to divide the users and conquer them, making each user agree not to share with others. I refuse to break solidarity with other users in this way. I cannot in good conscience sign a nondisclosure agreement or a software license agreement. For years I worked within the Artificial Intelligence Lab to resist such tendencies and other inhospitalities, but eventually they had gone too far: I could not remain in an institution where such things are done for me against my will.
So that I can continue to use computers without dishonor, I have decided to put together a sufficient body of free software so that I will be able to get along without any software that is not free. I have resigned from the AI Lab to deny MIT any legal excuse to prevent me from giving GNU away.
It's internally consistent and somewhat justifiable position… the problem for RMS and FSF lies in the fact that a tiny minority of people share that vision.
In an era where hardware was simple and software very expensive and rare (Microsoft Pascal was $300 back then and it was much, much, much less capable compiler than Rust) the idea to “free all software” sounded nice, but today we have an overabundance of software (both free and nonfree) and border between software and hardware is increasingly blurry… people simply don't even want to pursue that dream — even the ones who know that it exists!
In my view, those unrealistic goals are what has made us more free. So they keep being worth pursuing.
What I meant is that more realistic licences can get the help of more people, even if some of them might benefit from the code without making their code public.
GNU doesn't exactly make us more free, since the constraints are more binding. It tries to shoehorn the unconditional release of any source code based on it, but this has a significant drawback. If the ultimate goal is the community's benefit, I'm not sure it's the best strategy any more.
If you look at the most popular licences, open-source seems to come largely ahead (the title is "top open-source licenses", but I think the meaning is free and open-source software). This is only one site, though, and not something easy to measure.
Looks like the Rust compiler (rustc) and most of the official Rust toolchain (including cargo, rustdoc, and standard libraries) are licensed under the Apache License 2.0 and the MIT License. And who likes GPLv3 more for their own code (there might be reasons), both of these licenses seem compatible.
Software released under these licenses is Free software. I know, there was a time when Java was not, but even this is now gone with OpenJDK. Rust seems a very different case anyway. I recall that trademark issues were also raised with Red Hat Linux, which requested the removal of names and logos, but they never went so far as to say, 'This is not Free software.'
GNU has a page, Explaining Why We Don't Endorse Other Systems. The only one they call out for trademarks is Ubuntu, but they're ok with the base concept, rather complaining about statements on patent and IP law.
It's with noting that from a legal perspective (at least as I understand it!) trademark and copyright are distinct and unconnected rights. Since software licenses operate as a contractual agreement that grant a limited (to lesser or greater degree) exception to copyright specifically, I would think you need to explicitly mention a grant of trademarks for them to be considered part of that contract, which I don't think I've ever seen in a license or OSI definition etc.
In other words, "you can't limit the use of derivatives of this software" doesn't inherently also require that you allow someone to lie about being you, which is roughly what trademark is.
Whether the exact wording Stallman is taking issue with here does cause a problem would probably require a lawyer to be clear, but I suspect it's more a "be aware we do have a trademark here, and that we're explicitly calling out this may be an issue for you (and for making our case easier if we do want to sue someone we feel is abusing our trademark)" than a copyright limitation itself.
For reference I believe the clause he's referring to is this one in the Apache license:
- Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
That doesn't read to me as "you must remove all uses of trademarks", just that it isn't granting you the right to "use" them, that is, trade as and with the Rust trademark, though the explicit calling out of the NOTICE files does admittedly call that into question. (edit: here's near as I can tell the canonical explanation of that clause that seems to agree: Apache Software Foundation Trademark Policy | Apache Software Foundations)
There's no equivalent in the MIT license, so if he wants to he could just use that I guess?
That's what I'd already said three posts above, except I don't think they're compatible in both directions, as GPL is more restrictive than the two others. I also think there's some grey, potentially confusing area when talking about open-source and free software: Apache and MIT seem more "open-source" than the "free" GPL (which is more restrictive, thus actually giving less freedom). But I could be mistaken, as I'm not an expert.
I think the way to think about it is to consider who's freedom does the different licenses prioritise.
MIT, BSD and Apache all maximise the freedom of the developers. While GPL tries to protect the freedom of the end user over that of the developer.
This can be seen with appliances that run Linux. Due to the GPL the manufacturer has to provide the kernel source they built with. Which I consider a good thing, it lets me far more easily run a custom ROM on my android phone for example. GPL is all about forcing anyone using the code to also give back to the rest of the world.
The historical reason for this can be seen in the 70s and 80s "hacker culture", where RMS and others found that they had systems from Unix vendors that they wanted to improve, tinker and fix bugs on, but couldn't.
Personally I prefer to use copyleft licenses: if someone uses my code, they should give back any modifications they might make, either to upstream (via a PR), but at least to any downstream end users who wants to tinker with their devices.
They are not compatible in both directions.
How do you figure that? You can absolutely incorporate a MIT licensed work in a larger GPL 2 or 3 program.
I would give a link, but it seems FSFs page on this is having server trouble right now, so I can load to check which page exactly to link.
They have DDoS issues, maybe web archive can help.
Yes, that's what I said (twice). 
My point was that it could coexist in "free" software, but it's not free software because you can't use a GPL library as source in your project and keep an MIT licence, for example. If I understand correctly, that is. In particular, you can't use GPL sources in the standard library.
I understand the principle and where it's coming from, but I don't think it depends on whose freedom we consider: it's hard to tell whether the end user—who's not a developer in our scenario—benefits from "free" software vs open-source or even proprietary software, or not.
I agree that being GPL forces the vendor to publish the sources, but that doesn't necessarily make the device reprogrammable, as it usually comes with proprietary binaries that aren't public. For example, a part of Nikon's cameras software is public because it's based on Linux, but all their image post-processing algorithms aren't, and there's nothing you can do (besides, I'm pretty sure trying to load a custom firmware voids the warranty, let alone the risk of legal actions for reverse-engineering). In comparison, I mentioned Sony using open-source FreeBSD for its consoles: the end-users benefit from the same freedom, if perhaps not the same level of scrutiny (I believe that the Orbis OS isn't public, even though Sony's developer contributed to the FreeBSD project when they worked on the sources).
So I'd say it depends on the vendor willing to make it possible for users to modify the software, more than the use of GPL vs open-source in general. It's often possible to bypass that by reverse-engineering and hacking, but I think that's beside the point here.
We could also discuss the relative quality of the proprietary software. It's in the best interest of a company to release a good level of quality: it makes for good publicity, and the support / maintenance costs less. In comparison, free and open-source software is mostly developed as a hobby, so there's no way to guarantee its quality or even when a bug will be fixed. The end user entirely depends on the good will of the community, which is OK if the code in the device is commonly used in that configuration, but not if it's niche.
So here it depends a lot on the exposure and the competence of the developers.
I am confused as you say this yourself:
So I'd say it depends on the vendor willing to make it possible for users to modify the software, more than the use of GPL vs open-source in general.
That is right. So it matters. It is about users freedoms. There are many free-software valid licenses besides GPLs. But it is about the 4 freedoms. The 4 freedoms are user freedoms. Just as an example:
The GNU General Public Licenses (GNU GPL or simply GPL ) are a series of widely used free software licenses, or copyleft licenses, that guarantee end users the freedom to run, study, share, or modify the software.
If it is software that we can not modify and run a modified version of —in principle— then it is non-free software because it fails that you can re-distribute and run.
This is also about user-freedom because you can have open-source spyware or malware, and you may want to modify and run a freedom-respecting version of it. (related)
You talk about quality, but free software can be sold, and many companies exist on top of them. It is simply untrue this is hobbyist-only, or that you can not have services available.
To come back to OP, I think the issue is whether rustc impairs redistributing modified versions enough (whatever enough needs to be.) Or maybe there are some other issues. But I am unsure.
You talk about quality, but free software can be sold, and many companies exist on top of them. It is simply untrue this is hobbyist-only, or that you can not have services available.
Do we even have a single example left? For a long time RedHat was supposed to be such a company, but it's part of IBM now thus we are back to the “free software exist to bring people that would but other, non-free software”. Most other companies with GPL or AGPL offerings and “normal” proprietary licenses do the same thing.
I guess there exist one-person companies that sell free software, but in reality they sell and expertise and consulting services…
I think there are many if you think for a second.
But here you've one (Arduino), to my understanding.
I've also done paid free-software work as a company.
Donations are another channel (consider the whole fsf for example).
Consulting for their free software is common.
So it seems frequent to me. And better.