Just remember that all software you compile with it will be under the GPL.
Unlike other parts of GCC, GNAT copyright is held by AdaCore due to some special arrangement with the FSF.
For the compiled CE releases on their website, AdaCore strips the runtime exception:
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
You are of course free to build the compiler yourself, or use the Ada compiler that comes with your distro.
The sources are available, you just don't get a tag that tells you which exact combination of files AdaCore used to build and verify their binaries.
This is a strategic PITA, and AdaCore have in recent years made some moves to improve the situation, with being active on github and responding to issues in general.
If you compile this source (CE) - yes your code must be GPL. Adacore's distribution is the most up to date.
The FSF distribution has the normal gcc exceptions. The FSF distribution is normally what's shipped with linux distros. It tends to be slightly older.
Last time I used Ada, around ten years ago, the situation was exactly the same. This goes to show that the licensing issues around GNAT continue to hamper the ecosystem, contrary to what Adacore like to suggest.
You'll be violating the terms that allow you to use the compiler if your source code isn't GPL licensed. That doesn't mean your source code is automatically converted to GPL. It just means you don't have a right to use the compiler or to distribute the binaries you've produced with it.
> Unlike other parts of GCC, GNAT copyright is held by AdaCore due to some special arrangement with the FSF.
Adacore holds at least the copyright of their own contributions and therefore can decide whether they want to release their version of GNAT with or without the runtime library exception; the FSF version eventually inherits also the contributions of Adacore, but the Adacore version is more current.
> So yes, binaries compiled with that particular compiler are de-facto under GPLv3, and you have to abide by its terms
This doesn't have anything to do with source or binary version. The reason is that the binaries provided by Adacore are compiled from their (most recent) source version which they publish under GPL without the runtime library exception. For this (and only this) reason you create a "combined work" when you link your code with the Adacore version of the runtime library. This doesn't change in any way if you compile the GNAT version of Adacore by yourself; you still don't have the runtime libary exception which only Adacore can give for their contributions.
So do I.
> Adacore holds at least the copyright of their own contributions and therefore can decide whether they want to release their version of GNAT with or without the runtime library exception.
Indeed.
> the FSF version eventually inherits also the contributions of Adacore, but the Adacore version is more current.
AdaCore contributes to GCC, with some contributions copyright FSF, some copyright AdaCore.
AdaCore retains full rights on the later, limited by whatever private agreement they have with the FSF.
Whether it is more current or not is not relevant to the discussion, and given that GNAT CE has release cycles of 1 year it stands to reason that FSF GNAT gets bugfixes that GNAT CE will only get in 2022.
> This doesn't have anything to do with source or binary version.
I'm now pretty convinced you're reading things that I didn't write.
You seem to be under the impression that dual licensing only works because AdaCore GNAT contains newer files.
However, AdaCore can download stock upstream gcc, remove the linking exception from files they hold copyright over, and distribute this result in source and binary form on their website.
This is due to their unique status with the FSF, something that other companies and private contributors can not do.
Finally, I have never suggested recompiling AdaCore GNAT CE sources will result in a GNAT compiler with runtime exception.
Instead I've pointed out the mechanism of how they achieve this dual licensing: A) unique status as copyright holders alongside the FSF B) strategic inclusion or removal of the runtime exception in each and every file they hold copyright over.
Thanks, I studied law.
> AdaCore retains full rights on the later, limited by whatever private agreement they have with the FSF.
No "private agreement" is necessary. It's just about whether Adacore grants the runtime library exception for their contributions or not. And they apparently only do that with a delay (a year or so).
- FSF: Is GPL but contains an exception that allows you the create programs which are not GPL (basically the same as e.g. g++)
- AdaCore Community : Also GPL, but no exception. Hence your program is also GPL.
- AdaCore Pro: Commercial and allows you to create programs which are not GPL.
It's true that you may only use GNAT GPL for hobbyist use and GPL software.
But breaking GNAT's license doesn't make the software created GPL. It just makes you liable for damages. And cessation, of course.
> But breaking GNAT's license doesn't make the software created GPL
If you do not comply with the terms of the GPL license you're no longer allowed to use the code/software licensed under GPL. Under GPL 2, you can continue to use the code/software after the license violation is removed. Under GPL 3 the copyright holder might terminate your license (see section 8 of GPL 3).
Essentially a case of "coding for standard interface offered from multiple sources where the interface itself isn't GPL" vs "Your code requires rework in order to work without this specific GPLed dependency".
This is all grossly simplified, but among other things, it means that separating GPL code to another binary you talk over any form of IPC doesn't necessarily mean you're avoiding GPL.
It's rather "whether your work", not only your code. GNAT generates runtime library dependencies even if you are not aware of it. So the result is a "combined work", because the runtime library is linked to your code (otherwise your application wouldn't work).
See e.g. https://www.gnu.org/licenses/gpl-faq.html#GPLStaticVsDynamic
This is an important distinction.
But it's still true, that using the Ada core GPL Ada compiler, which does not come with lgpl/run-time exception - you can only legally distribute binaries under the GPL (or commercial license).
This does not matter much if you don't distribute code to others (eg: break system of a car - gpl/commercial; build a web server to sell/stream movies - gpl/internal use).
I still think it's probably a mistake to have the fsf and Ada core version be so similar, yet differently licensed (because it is confusing - most are used to gpl compilers comming with lgpl/runtime exception, like gcc).
This is a bit painful (intentionally so) but it can be done.
How does that work? Are the binaries from Ada core (not FSF) intentionally distributed under GPL while the source for standardlib/run-time come with LGPL/run-time exceptions?
It was my understanding that the Ada core distribution is full GPL only, and the FSF one (lagging a few versions) was licensed more like gcc?
Yes that's the case.
https://github.com/gcc-mirror/gcc/blob/master/gcc/ada/libgna...
Compare with the same file from the GNAT 2021 CE install:
GNAT/2021/lib/gcc/x86_64-pc-linux-gnu/10.3.1/rts-native/adainclude/g-socket.ads
you will find there are a bunch of blank lines where the runtime exception was.
I am not wrong. The runtime of the Adacore Community edition is under GPL, as are many libraries included in the Adacore edition that are not included in the FSF edition. Your binaries will be under the GPL. (Technically speaking, you could compile executables with this version of GNAT that are not under GPL by writing your own runtime. Practically, this is pretty much impossible and nobody has ever done it.)
The FSF edition allows you to compile executables without license encumbering, because it is licensed under the mGPL.
And you've been wrong for decades.
All the things you write are true, except when you claim that the binaries will automatically be GPL.
The author has to make them GPL, in order to comply with the license, that's true. But they don't magically become GPL if the author refuses.
If the author doesn't comply, Adacore can sue them. They can demand that the author stops distributing non-compliant binaries. They can demand that the author pay them money.
They cannot, for example, redistribute the binaries themselves (against the author's wishes), under the theory that they "should be" GPL.
The court probably wouldn't even order the author to put the binaries under GPL, because specific performance is generally not considered by the courts, when paying damages is a workable alternative.
I wrote the comment because many people don't know the difference between the FSF version and Adacore's Community Version, hence will involuntarily violate the GPL.
"If the resulting software were GPL, all those nasty contradictions would go away. Let's assign GPL to the software and the problem is solved."
Unfortunately, the law doesn't work that way.
If you want mGPL (with the runtime exception) you need to wait for the FSF version.
This is well-known in the Ada community, but I thought I'd mention it because occasionally people don't know the license conditions of various GNAT versions very well. Such as you.
There is a commercial license to help encourage the big well funded customers to pay for the tools they need to compile millions of lines of company confidential ADA.
And a license for only open source software; just in case students or hobbyists want to write their own robust open source rocket guidance system and share it on github.
I mentioned it precisely because people get it wrong so often.