For Pedestal, I set up a system for CLAs (contributor license agreements); it was quite easy, basically a GitHub action, and the CLA itself is pretty much boilerplate. I can go back and figure out what I did for Pedestal and we can set something up for Dialog.
Not that I’m too likely to contribute to Dialog, but requiring a CLA is a HARD NO for me in terms of contributing to projects that are presently open-source…
4 Likes
What would be the practical effect of a CLA on the project? I think so far we’ve just been vaguely assuming that anyone contributing to the project licenses their contributions under the terms of the LICENSE file, and I don’t think any of us want to relicense the whole thing. But making it explicit that any contributions are licensed the same as Linus’s original code wouldn’t be a bad idea.
1 Like
Conveniently this bit is already mentioned in the contributing guide!
I agree that a CLA seems like a non-starter… doesn’t really solve any problem I’m aware of, and 99% of the project is Linus’ work which is only available to us under the existing license anyways.
2 Likes
Well, MIT-licensed code can be incorporated into an (e.g.) GPL-licensed project, so we could theoretically change the license going forward if we wanted to…but I don’t think any of us want to. The GPL is a massive headache for compilers, because you have to use weird loopholes and workarounds to keep it from GPL-licensing every project compiled with it, and I prefer the MIT/BSD paradigm anyway (even for things that aren’t compilers).
1 Like
For sure - I can take new GPLed code which I wrote and combine it with the BSD-licensed code which Linus wrote and legally release a project that contains both.
What I can’t do is take Linus’ code and say “actually, this code is now GPL”, because the GPL makes promises that Linus never made, like a patent grant. (If Linus had signed a CLA that assigned me the copyright, that would be allowed. But he hasn’t, and I wouldn’t want it anyways!)
Sorry - I appreciate this is pedantic and overlaps with what you’ve already said. But when it comes to licensing, the pedantry is to some extent the point… and I of course agree with everything you say about the GPL etc.!
1 Like
I guess you can’t relicense somebody else’s work (not really sure), however if you introduced new code under the GPL, or link to a GPL library like GNU readline, then the whole project essentially becomes GPL.
1 Like
Hang on, the project doesn’t become anything. You’re in control: you just chose to put yourself in the position of releasing under the GPL or crossing your fingers and violating the license you were granted.
1 Like
This is definitely a place to be pedantic! But…
I’m not sure that this, in particular, is a useful distinction. If the Dialog compiler is relicensed under the GPL, then does it really matter if any projects compiled using it “become” GPL, or if anyone using the compiler “puts themselves in the position of releasing under the GPL, or violating the license”? To me it seems equivalent to quibbling about whether I’m required to stay under the speed limit, or if by getting a driver’s license and using a public road I chose to put myself in the position of either obeying the speed limit or violating traffic laws.
(I guess it matters because it affects who can sue whom over license violations: if you incorporate GPL-licensed work into your project but don’t release it under the GPL, then I use it under the terms of the GPL, you can sue me, but I can’t sue you, only the original author of the GPL-licensed code you used. But this is also a famously non-litigious internet community.)
((And of course anyone can sue, but by “can sue” you can assume I mean “can sue with any chance of success”, and so on and so on…))
GCC uses a complicated modified version of the GPL to avoid spreading the license (or the obligation to release under the license etc etc etc etc etc) to any programs compiled using it, but the main reason to relicense Dialog would be so we could incorporate GPL code, and using a modified version of the GPL doesn’t let us do that. Which means, from my perspective at least, there’s a lot of downside and very little upside (unless you have strong feelings about IF authors’ moral obligation to release their source).
Which gets back to…
It sounds like our existing contributor guidelines include releasing your code under the current (BSD) license; and while we could work to change the license going forward, Linus isn’t very involved in the project any more, and the vast majority of the code is his. So in my opinion, there would need to be some very strong benefits to a new license—and, also in my opinion, restricting the way authors can release Dialog-compiled projects is much more of a drawback than a benefit.
So, if we don’t plan to relicense the project in the future, what would be the benefits of a CLA? I’m legitimately asking—I haven’t done a lot of open-source work before, so I’m not sure what the advantages are over just a notice saying “by making pull requests to this repository, you agree to let those changes be distributed per the repository’s LICENSE file”.
A CLA is mostly useful when people are working on an open source project on work hours. It handles their contributions which would be considered the property of their employers being assigned to the open source project instead. It would be marginally useful if everyone is working on the project as a hobby.
2 Likes
Ah, that makes sense! I hadn’t thought about that aspect.
Once a program becomes GPL, you are forced to distribute the text of the GPL license with any binaries, and mention its GPL-ness in documentation, as per this rule:
So in my book, that means the program does become GPL software.
1 Like
I just object on principle to spooky descriptions of the GPL. Regardless of whether it would be a good or viable choice for Dialog. (Presumably if (a modified) Dialog compiler were released under the GPL, some saint would figure out the necessary machinations to not place requirements on users’ games–I think this would amount to putting the standard library under the current license, not that I’m advocating for any change.)
But a program doesn’t “become GPL”. You might receive a copy of a program, licensed to you under the GPL by its author. Let’s not make this sound nefarious.
I don’t think this is quite right. We can’t do the latter and “re-license” Linus’s code at all, as we aren’t the copyright holder. We could do the former, since it’s possible to comply with the GPL’s requirements with respect to the whole program, while simultaneously complying with the laxer requirements of the BSD code. Except we’d be taking a gamble with regard to whether the BSD license implies a patent license, even with this “contains both” strategy.
In fact, we do take this gamble if we use Dialog at all! But we don’t take the additional risk of people putting work into this program, then finding that the license makes a false claim and Linus is patent trolling us. He may still troll us, but the BSD license doesn’t claim he won’t, so the situation would be legally clearer I guess?
But this is getting off-topic since license changes were only brought up as an example anyway.
Unfortunately, the GPL is really bad for compilers in general: the guts of the Dialog compiler contain 4,000-some lines of Z-machine assembly that gets copied verbatim into any program that needs it (e.g. every program includes R_TERPTEST, which makes sure the interpreter is functional, while anything compiled in debug mode includes R_TRACE_QUERY, which handles call tracing, and so on). This makes any program compiled with Dialog a derivative work of the compiler for GPL purposes. (Same with Ă…-machine assembly, though somewhat less of it. Still enough to be a derivative work unfortunately.)
This is why GCC isn’t entirely GPL-licensed. Most of the source is under the GPL, but there are a couple special massive files that store all the little assembly chunks used during compilation, and those files specifically have a more permissive license (the “GPL With GCC Runtime Library Exception”). A lot of very careful calls back and forth during compilation are used to make sure that end users’ programs are only derivatives of those special files, not any of the other compiler code. And anyone working with GPL-licensed code for other parts of the compiler needs to make sure none of it ever enters the special files, because if the GPL ever spread to those, it would then spread to everyone’s compiled programs.
(The “GCC Runtime Library Exception” is even more complicated than that, because it specifically ceases to apply if any element of the compilation toolchain is not available under the GPL, as a threat against anyone trying to modify or extend the compiler with differently-licensed plugins. As soon as you try to do that, the exception no longer holds, and all resulting programs must be released under the GPL. They were worried about allowing plugins at all in case people developed proprietary ones, and this was the solution.)
Dialog mostly puts all the Z-machine assembly in one file (runtime_z.c), but not all of it, and it would require a major refactor to get every inline assembly instruction into that file and no other (and likewise for Å-machine). That’s why I say it’s not feasible for Dialog to switch to a strong copyleft license, even if we wanted to—compilers are just, architecturally, not a good fit for them. I understand what the Free Software Foundation is going for with the GPL, but from my side (I had to read up on all these details when the relicensing topic came up!) it’s just a colossal headache. If we want to let people compile closed-source games with Dialog—which I personally do, at least, people tend to avoid compilers that limit how they can release their compiled programs—it’s best to just avoid it altogether.
4 Likes
For what it’s worth, what you say here seems to agree 100% with what I have above! (I could do one thing but not the other.) Sounds like we’re on the same page.
1 Like
I appreciate the discussion. This thread has inspired me to clarify the licensing of some parts of my otherwise-GPL’d compiler.
3 Likes
And to be clear, I don’t mean to say this is a nefarious plot on the part of the FSF or anything—exactly the same problems would come up with a proprietary compiler that didn’t allow any redistribution. In that case the problem would be solved by all the programmers (presumably) signing over their IP to the company, which could then decree “anything that we put in this file can be redistributed, and anything we put in this file can’t”, without any contributors’ rights getting in the way. The issue is inherent to compilers in general.
Since we don’t want to do that (I don’t think any of us want that sort of CLA), I think a weak copyleft license is the best solution. That way, any code that anyone contributes (under that weak copyleft license) can end up in the compiler or the runtime or the library or wherever it works best.