[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [fluid-dev] Another application using FluidSynth announced

From: Matt Giuca
Subject: Re: [fluid-dev] Another application using FluidSynth announced
Date: Mon, 12 Sep 2011 22:05:33 +1000

> Yes, you can release a GPL application that requires proprietary operating
> systems and compilers. Nothing is said about money, though.

Yes, you can release a (L)GPL application that requires proprietary
operating systems and compilers. That is why it is valid to release
FluidSynth for Windows. It is valid to say "you won't be able to run
this free software unless you pay money for the operating system which
it requires."

However, making your own customised version of FluidSynth for Windows
requires just one proprietary thing: Windows. Windows is "the
operating system on which the executable runs" so it is excluded from
the LGPL's requirement that it be distributed with the work. You could
argue (as I did facetiously above) that the FluidSynth team is
required to distribute GCC along with FluidSynth, because GCC is not
"normally distributed ... with the major components ... of the
operating system on which the executable runs." But that's a bit of a
silly argument because GCC is available for free, so it would be
ludicrous to include it in the FluidSynth distribution. If worst came
to worst, you could always "Accompany [FluidSynth] with a written
offer ... to give the [user a copy of GCC]." So it is perfectly valid
to release LGPL software on Windows.

As David pointed out, there is a slight incongruity with free software
that requires proprietary compilers. Ignoring the obscure case of
software that uses Microsoft-only extensions, there is also the case
of software that uses proprietary languages, such as .NET (pre-Mono,
or using Microsoft-only features). Perhaps technically that should be
excluded too, but I'm not here to comment on that case. I think it's
possibly rare enough to overlook.

However, iOS (un-jailbroken) is a very different beast. As far as I am
aware, the following tools are required to completely reproduce a
working binary of an app that runs on an un-jailbroken iOS device:

1. An Apple Macintosh, required to run XCode
2. XCode, required to compile software
3. An Apple developer license ($99), required to sign the binaries to
run on the phone (certainly for distribution, but I believe even for
testing / individual use)
4. Explicit approval by an Apple employee, on a case-by-case basis
(required for distribution)

I list these because these are what I would consider to be part of the
LGPL's "any data and utility programs needed for reproducing the
executable from [the work]."

The first two are interesting because even though XCode is free, I
note that unlike the Visual Studio case, XCode is not a component "of
the operating system on which the executable runs". The operating
system on which the executable runs is iOS. XCode requires Mac OS X.
The LGPL explicitly says it must be the same operating system, because
otherwise Microsoft could release a "Windows Developer Edition" and we
would want the LGPL to prevent the possibility of writing software for
"Windows Standard Edition" but which requires the much more expensive
"Windows Developer Edition" in order to compile. Then the software
wouldn't be free (libre), because the ordinary user of the
(non-gratis) operating system would not have the power to modify the
software without a much larger (non-gratis) purchase. It is the same
with iOS, because anybody who has an iPhone does not necessarily also
have a Mac, and therefore are powerless to rebuild the software for
their own operating system.

The third one is the same argument I brought up before: Because the
Apple developer program ($99) is *not* "normally distributed ... with
the major components ... of the operating system" (even if we consider
that operating system to be the Mac). As far as I know, while XCode is
free, this license is required in order to test the software on a real
phone. Therefore, without that license, you cannot "reproduce the
executable" (the actual binary that can run on the iOS device). As
Pedro pointed out, gratis isn't *really* the issue. But it sort of is,
because if it was free, like the facetious GCC argument above, it
would be a very weak argument to claim non-compliance with the LGPL
because it didn't include a free tool. But since it costs $99 per
year, that really is a valid argument. I cannot reproduce the binary
without this tool, which is not distributed with either Mac or iOS,
and would cost money to purchase. Therefore, that tool must be
included with the LGPL'd software. As this would violate Apple's
license restrictions, it implies that iOS is incompatible with the

I put the fourth one there, even though it's only required for
distribution. It's hard to say whether the LGPL covers this, but I
would say it does. Even though you can compile a *test* version of the
software with just steps 1-3, you haven't reproduced the executable,
because the executable, in its original form, was able to run on iOS
devices without a developer license, and the one you reproduced is
not. Therefore, without step 4, you are unable to reproduce the same
executable -- specifically, you are only able to produce a crippled
executable that won't run on any other device than your own -- surely
against the spirit, if not the letter, of the (L)GPL. So I consider
step 4 to be part of the programs needed for reproducing the
executable. You might also say that it isn't a "data or utility
program", since it is a human step, equivalent to knowing how to use a
makefile. But that's not true, because it *is* a utility program -- a
human at Apple is going to use a program to sign that binary, as well
as secret data (the Apple primary key). So there is both data and a
program involved in that step which you certainly cannot distribute,
nor is it included with the operating system.

To summarise, any iOS app, even if its source code is fully disclosed,
cannot possibly grant all of its end users the ability to reproduce
the executable, for three reasons:
1. It requires a Mac, which is not the same operating system as iOS,
2. It requires a subscription to the Apple developer program, without
which it is impossible to test on a real device,
3. It requires explicit approval from Apple, without which it is
impossible to distribute to others.

On my point 3, it may seem like I am being overly picky. (Surely it is
sufficient that the user can modify the program and test it without
the ability to distribute their modified changes to others?) But no --
point 3 is in fact essential in the Free Software Foundation's
definition of free software. From
https://www.gnu.org/philosophy/free-sw.html, the final of the "four

"The freedom to distribute copies of your modified versions to others
(freedom 3)."

This last point is one of the main reasons the (L)GPL was written in
the first place.

reply via email to

[Prev in Thread] Current Thread [Next in Thread]