This question already has answers here:
Closed 13 years ago.
Possible Duplicate:
Using LGPL library in a commercial Java application
Hello guys!
There is a project under the GNU Lesser GPL license. I want to use this project in my application. Can I sell my application using this license?
In a nutshell, the idea of LGPL'd projects (usually libraries) is that you are free to use them as you wish in your own application, be it open or closed source, free or proprietary - as long as you publish the source code of the LGPL'd part (if you modify the LGPL'd part, you must publish the modified sources, under LGPL).
Additionally, the libraries must be linked dynamically so that they could be replaced to another version by the user if he so wishes. For libraries (.dll, .so, .jar...), this is usually self-evident. Side note: this is inherently pointless requirement, because nothing requires that your application works with any other library version than the one that you originally provided. You could even actively prevent your application from working with other versions.
You can use LPGLed libs with your proprietary software, but there are some restrictions you must observe. Better read the LGPL carefully and contact a lawyer.
General notes, You can use a LGPL library if
You link with it dynamically only allowing user to replace specific library (for example replace dll to newer compatible version).
If you make changes in LGPL code, you release the changed library sources as well.
Generally many closed source projects use LGPL code, it is common practice, but
read license carefully, especially this GPL-FAQ.
If you have doubts, contact lawyer.
If you are using the GNU app as part of the development process, then the resulting code is saleable.
If you are calling or otherwise using the public APIs of the GNU app then your app is saleable provided you package and distribute the GNU app as a separate component complete with the original app -- and make it clear in your documentation that you are using the GNU library and it still belongs to its original authors under the GNU license terms.
If on the otherhand you have modified the package, cut and pasted code from the package, inserted your code into thier programs or otherwise changed thier code to get yours to work you can only further distribute with the same gnu license. This does not actually preclude selling the software, but, there are all sorts of complications so its best not to go there.
If in doubt contact the original authors, tell them what you have done/intend and ask them what they think - it is afterall thier software your messing with.
Short answer is yes, you can sell your application under any license you like. The only thing you need to do is:
Mention somewhere that your product uses that library, anywhere, in the about box, in the splash screen, in the manual...
If your customers ever ask for the source code of that library (not necessarily your application), then you must give it to them or tell them how to obtain it. But note that only your customers/users actually have this right (and most customers don't bother right?).
That is basically it in a nutshell though I would still recommend you read the GPL FAQ posted by Artyom.
Related
My friend is currently in preparation of distributing his software and wants to cleanup on the licenses of software he uses. The strategy is that he collects all the files that provides the licensing text.
He finished collecting all the "obvious" licenses, such as the Qt license of the Qt libraries he uses. However he also uses some of the Windows DLLs that come with Windows, such as kernel32.dll and advapi32.dll.
Where can he find the license files so that he can publish it with his software? The first DLL file, kernel32 appears to be automatically linked to his software based on an http://en.wikipedia.org/wiki/Auto-linking directive. The second file, advapi32.dll is linked explicitly to his software, and he wants to cleanup the situation of that file by collecting the file that provides the license.
For debian linux for example, he knows that the files are below /usr/share/doc/<package of the library>/copyright.
Not an option, distributing those Windows components cannot work. Different Windows versions have very different implementations of these DLLs. Even computers with the same version may have different DLL versions, these runtime components are often updated by Windows Update. Forcibly overwriting them would be normally disastrous, but the File System Protection feature in Windows recovers the damage.
There simply is no need to distribute these DLLs. Every Windows machine already has them, along with a solid promise from Microsoft that they will be compatible with the program as long as the programmer set the _WIN32_WINNT macro correctly in his code. Which selects the minimum Windows version that he chooses to support, it prevents accidentally taking a dependency on winapi functions that are only available in later versions. Getting that wrong simply prevents the program from starting.
Since you mentioned GPL in the comments, you need to know that GPL has special language concerning system libraries.
The GPL FAQ says
Both versions of the GPL have an exception to their copyleft, commonly called the system library exception. If the GPL-incompatible libraries you want to use meet the criteria for a system library, then you don't have to do anything special to use them; the requirement to distribute source code for the whole program does not include those libraries, even if you distribute a linked executable containing them.
Naturally you should rely on the actual legal language of the license, not the FAQ. Hopefully any infectious non-GPL licenses take a similar approach.
The license that applies to Windows system DLLs is the end-user license for the desktop or server OS that they came with. There are many variations on these, such as volume licenses or development subscription licenses. So your friend needs to just chalk those up as "system library, non-distributable, source not distributable, governed by OS license".
Contrary to Alex's assertion in the comments, the Windows license does (or at least attempts to) govern use in addition to redistribution. Running the application in, for example WINE, where there may not be a valid license for certain required system libraries would present a problem, even if the system libraries were placed onto the hard drive during installation/patching of a licensed copy of Windows. I am not a lawyer, but I'm pretty sure that problem falls on the administrator of the WINE environment who caused those DLLs to be loaded, not the third-party application developer.
You may not redistribute Windows system DLLs. This includes kernel32, ntdll, advapi32, and a couple of others. The exact list is not fixed but basically, it includes almost anything in the system32 directory. (This list may be a good start.) These files are considered to be part of Windows and thus covered by Windows EULA.
What you may redistribute depends on your compiler and/or any third-party (non included in Windows) libraries you're using. For Microsoft Visual C++, see redist.txt in the installation directory. It usually has a text similar to following:
Visual C++ Runtime files
Subject to the license terms for the software, you may redistribute the .EXE files (unmodified) listed below.
These files can be run as prerequisites during installation.
vcredist_x86.exe
vcredist_x64.exe
vcredist_IA64.exe
Subject to the license terms for the software, you may redistribute MSM files listed below unmodified as a part of your installation package:
[...]
See here on the specifics of redistributing MS C runtime.
For other compilers/libraries you will need to consult their documentation.
Basically, I want to seperate some common functionality from existing projects into a seperate library project, but also allow a project to remain cross-platform when I include this library.
I should clarify that when I say "cross-platform" I'm primarily concerned with compiling for multiple CPU architectures (x86/x86_64/ARM).
I have a few useful functions which I use across many of my software projects. So I decided that it was bad practice to keep copying these source code files between projects, and that I should create a seperate library project from them.
I decided that a static library would suit my needs better than a shared library. However, it occurred to me that the static library would be plaform dependent, and by including it with my projects that would cause these projects to also be platform dependent. This is clearly a disadvantage over including the source code itself.
Two possible solutions occur to me:
Include a static library compiled for each platform.
Continue to include the source code.
I do have reservations about both of the above options. Option 1 seems overly complex/wasteful. Option 2 seems like bad practice, as it's possible for the "library" to be modified per project and become out-of-sync; especially if the library source code is stored in the same directory as all the other project source code.
I'd be really grateful for any suggestions on how to overcome this problem, or information on how anyone else has previously overcome this problem?
You could adopt the standard approach of open source project (even if your project is not open source). There would be one central point where one can obtain the source code, presumably under revision control (subversion, git...). Anyone who wishes to use the library should check out the source code, compile it (a Makefile or something similar should be included), and then they are all set. If someone needs to change something in the library, they do so, test their changes, and send you a patch so that you can apply the change to the project (or not, depending on your opinion on the patch).
At the moment I am trying to find a gettext alternative with comparable tool support. However, the library itself needs to be under a permissive license, so that the binaries can be linked statically and I need not release the object files along with the binary as the LGPL stipulates.
In short: one of the so-called permissive licenses (BSD, MIT, zlib/libpng, X11 etc ...) would suit me fine, but I haven't been able to find an alternative under permissive license.
Any pointers?
Yes, I have seen and read the one answer to https://stackoverflow.com/questions/943058 and downvoted it. The question clearly was for non-copyleft, too. And the LGPL is a copyleft license, even if it is more permissive compared to the GPL.
NetBSD maintains a gettext-compatible library, under BSD license.
see http://wiki.netbsd.org/projects/project/libintl/
it needs development, so anything that is missing you could develop and contribute :)
This should also be mostly compatible with the 3rd party gettext tools and utilities, if you
can get them to compile from source against libintl.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question does not appear to be about programming within the scope defined in the help center.
Closed 7 years ago.
Improve this question
I've seen some software (a Joomla component, to be exact) for sale on a web site. The web site says it is licensed under the GNU GPL2. However it also says you need to pay for every site you use the software on (with bulk discounts).
I know it's perfectly acceptable to sell software under the GPL, however the license implies that the source code must be distributed at no cost.
So is this a legitimate use of the GPL, or is it violating the license? Is it legal to download the software for free (say, from Bittorrent) and use it as I wish?
Here is a FAQ from the GNU site. I think it answers your question:
Does the GPL allow me to sell copies
of the program for money?
Yes, the GPL allows everyone to do this. The right to sell copies is part
of the definition of free software.
Except in one special situation, there
is no limit on what price you can
charge. (The one exception is the
required written offer to provide
source code that must accompany
binary-only release.)
http://www.gnu.org/licenses/gpl-faq.html#DoesTheGPLAllowMoney
Further more:
If I distribute GPL'd software for a fee, am I required to also make it
available to the public without a
charge?
No. However, if someone pays your fee
and gets a copy, the GPL gives them
the freedom to release it to the
public, with or without a fee. For
example, someone could pay your fee,
and then put her copy on a web site
for the general public.
For GPL software, the source code must be distributed with the binary version or upon request to anyone who legally obtains the binary version.
Ergo, if you didn't buy the product from them, they are under no obligation to give you the source code.
The obvious flip side to this is that anyone who DOES legitimately get the source code is free to redistribute it as they please.
From my understanding distributing it on bittorrent would be redistribution which is permitted under the GPL without limitation (however Trademarks etc could still be violated!) This is how projects like CentOS work - they remove the trademarks, rebuild and then redistribute - and this is perfectly legal.
The company themselves are under no obligation to release source code unless they distribute the software to you.
So your options are:
Get it from someone else (who redistributes it under the GPL)
Purchase the product from the company - they'll give you the source code
I would personally suggest the latter option because it supports companies that support the GPL!
One question is whether the author wrote all the software or used any pre-existing GPLed software. If the person on the web site owns the copyright completely, then the web site may impose any conditions, including those incompatible with the GPL. Of course, releasing it under the GPL gives you some rights by itself. In particular, you can't redistribute without the source code, but you can make copies and use them.
The above practice is generally considered unfriendly by Free and Open Source Software advocates. Since it's not really honest to advertise GPLv2 and not deliver everything necessary, I'd advise being careful about the product. People who deliberately misrepresent things in advertising are likely to be selling shoddy software.
If the software contains pre-existing GPLed components, and the author didn't come to other terms with the copyright holders, then the GPL applies in full. The distributor has to provide source code (either with the executable or on request at nominal cost) and may not impose restrictions not allowed by the GPL.
There's also the possibility that the author released under GPLv2 without actually understanding the license. This happens from time to time, and frequently the FSF will quietly work with companies on getting into compliance.
In either case, it's perfectly fine to sell the software. If somebody else has the software including the source, they can redistribute freely, and it's perfectly legal for you to get it from them.
This is obviously a very simple business trick that relies on the naivity of the purchaser. It is obvious that, if the component is GPL, you can get it from any other user (bittorrent, file sharing), redistribute it and even resell it (but keep it GPL).
It is also very obvious that, if there's no other source to find/get it from, if you purchase, there is absolutely no need to pay multiple times for it. You just need to buy it once, and re-use it on all of the websites that you wish.
Even if it has some source of protection, the source code is open, so you can easily remove that protection.
Just out of curiousity, can you please give the name/website of the Joomla! component?
Closed. This question is off-topic. It is not currently accepting answers.
Want to improve this question? Update the question so it's on-topic for Stack Overflow.
Closed 9 years ago.
Improve this question
I find it unnecessarily duplicated to have it in each code file, but I see it on most open source projects. Should I do that same, or just include a single license outside the code?
A single one outside the code, please! I don't know about the others, but I hate seeing the same thing on top of every file.
I think I've read it a few times, just by page_down-ing through it.
EULA is the wrong term here, as the people looking at source code usually are not end users.
Legally, it makes no difference either; copyright does not need to be declared explicitly.
Basically, all you achieve is a lower risk of people accidentally violating your license terms. You'll have to decide how important that is to you.
I'd say the best compromise is to put a very short header containing a link (absolute URL as well as relative within the project) to the full license text into each source code file. That way, anyone who cares about the license knows where to find it (ideally, people who're willing to pay massive license fees; you certainly want those people to be able to contact you!)
It might depend on the license. The GPL distinguishes between preamble and license. It clearly states, that the (annoying) preamble must be part of the code:
Can I omit the preamble of the GPL, or the instructions for how to use
it on your own programs, to save space?
The preamble and instructions are integral parts of the GNU GPL and may not be omitted. In fact, the GPL is copyrighted, and its
license permits only verbatim copying of the entire GPL. (You can use
the legal terms to make another license but it won't be the GNU GPL.) (1)
Source:
1) http://www.gnu.org/licenses/gpl-faq.html#GPLOmitPreamble
See also http://softwarefreedom.org/resources/2012/ManagingCopyrightInformation.html
A free ebook from ifrOSS explains and comments the GPL 2 in german language. There is another one for GPL 3
For a well founded answer you should ask for a legal advice which is not available on sx. If you can not find a lawyer for your (open source) project, have a look at the FSFE legal network.
No, you don't have to put the license in each source code file.
If you look closer, most FOSS applications don't do that either. They put a copyright statement at the top of each file and a short sentence telling you what license the file is under and where you can find the full text of the license. They usually point you to the COPYING or LICENSE file containing the full text of the license and/or to a website that contains the full text (in case the COPYING file isn't there anymore).
Like Michael Borgwardt said in his answers, legally you don't have to do this. But it is advisable for source code that you intend to distribute since people can immediately see who has the copyright and what the license is.
I think the reasoning behind putting it in each file is a legal one. If the agreement is in each file, there is no chance of someone stumbling across a piece of code without being exposed to the license.
It may not be a good one, but all the big boys use it so if it's just visual pain, I would look for a better reason not to do the same.
If you're using GPL this is more of an issue, but if you're using public domain licenses like BSD or MIT, I don't think you really care what people do with the code anyway. I suppose it depends on how strict your license is.
IANAL,
Assuming you are talking about licensing, not a EULA, you can put the license outside. This is almost always done with really long licenses such as the GPL. It would be silly to put the entire GPL license in every file. Usually you would just have some type of notice saying where you can find the actual license. This is perfectly legal. However, with really short licenses such as BSD/Apache/MIT/whatever, it is simpler to just include to license in every file, since the notice saying where to find the license would be almost as long as the license itself.
If your code is going to be compiled so you are just distributing a binary then it really does not matter. Because when you create a binary, the comments are removed before the compilation process takes place. It only matters if you will be distributing the actual source code either open source or closed source. This typical matters if you will be distributing a application in a scripting language that doesn't compile.
It depends on what the license dictates. The GPL, for example, instructs you to put a short notice in every source file, include the entire license somewhere in your source distribution, and make your source distribution available to anyone who get a copy of the binary distribution.
If you disagree with this, and it is YOUR code, you're free to choose a more agreeable license, or create your own.
You dont need it for the license, a single external file will do as long as its clear what files it covers.
However for Copyright you should have the copyright notice on every piece of text.
What I do is to put a two-line comment at the top of the file, stating my company's name, last revision date and the name of the license the source file has, then at the very bottom of the file a short version of the license.
Of course, the full license (all of them in case of multiple licenses) is always enclosed on source file and release directories.