Gpl with commercial software

The one exception is the required written offer to provide source code that must accompany binary-only release. You can charge any fee you wish for distributing a copy of the program. If the binaries being distributed are licensed under the GPLv3, then you must offer equivalent access to the source code in the same way through the same place at no further charge.

In fact, a requirement like that would make the program nonfree. If people have to pay when they get a copy of a program, or if they have to notify anyone in particular, then the program is not free.

See the definition of free software. The GPL is a free software license, and therefore it permits people to use and even redistribute the software without being required to pay anyone a fee for doing so. You can charge people a fee to get a copy from you.

You can't require people to pay you when they get a copy from someone else. 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. The GPL says that anyone who receives a copy from you has the right to redistribute copies, modified or not. You are not allowed to distribute the work on any more restrictive basis. If the violation involves GPL-covered code that has some other copyright holder, please inform that copyright holder, just as you would for any other kind of violation of the GPL.

Thus, anyone who receives a copy of your version from you has the right to redistribute copies modified or not of that version. You may not distribute any version of the work on a more restrictive basis. For instance, you can accept a contract to develop changes and agree not to release your changes until the client says ok. You can also release your changes to the client under the GPL, but agree not to release them to anyone else unless the client says ok.

The GPL would give the client the right to redistribute your version. In this scenario, the client will probably choose not to exercise that right, but does have the right. You can certainly get credit for the work. Part of releasing a program under the GPL is writing a copyright notice in your own name assuming you are the copyright holder.

The GPL requires all copies to carry an appropriate copyright notice. No, this is not permitted under the terms of the GPL.

While we recognize that proper citation is an important part of academic publications, citation cannot be added as an additional requirement to the GPL. Requiring citation in research papers which made use of GPLed software goes beyond what would be an acceptable additional requirement under section 7 b of GPLv3, and therefore would be considered an additional restriction under Section 7 of the GPL.

And copyright law does not allow you to place such a requirement on the output of software , regardless of whether it is licensed under the terms of the GPL or some other license. Including a copy of the license with the work is vital so that everyone who gets a copy of the program can know what their rights are. It might be tempting to include a URL that refers to the license, instead of the license itself.

But you cannot be sure that the URL will still be valid, five years or ten years from now. Twenty years from now, URLs as we know them today may no longer exist. The only way to make sure that people who have copies of the program will continue to be able to see the license, despite all the changes that will happen in the network, is to include a copy of the license in the program.

Without such a statement, it's not entirely clear that the permissions in the license really apply to any particular source file. An explicit statement saying that eliminates all doubt.

A file containing just a license, without a statement that certain other files are covered by that license, resembles a file containing just a subroutine which is never called from anywhere else.

The resemblance is not perfect: lawyers and courts might apply common sense and conclude that you must have put the copy of the GNU GPL there because you wanted to license the code that way. Or they might not. Why leave an uncertainty?

This statement should be in each source file. A clear statement in the program's README file is legally sufficient as long as that accompanies the code , but it is easy for them to get separated. Why take a risk of uncertainty about your code's license? You should put a notice at the start of each source file, stating what license it carries, in order to avoid risk of the code's getting disconnected from its license.

That other context may not show what the file's license is. It may appear to have some other license, or no license at all which would make the code nonfree. Adding a copyright notice and a license notice at the start of each source file is easy and makes such confusion unlikely. If a whole software package contains very little code—less than lines is the benchmark we use—you may as well use a lax permissive license for it, rather than a copyleft license like the GNU GPL.

Unless, that is, the code is specially important. We recommend the Apache License 2. They will not make a substantial fractional change in the size of a software package unless the package itself is quite small. In order to combine two programs or substantial parts of them into a larger work, you need to have permission to use both programs in this way. If the two programs' licenses permit this, they are compatible.

If there is no way to satisfy both licenses at once, they are incompatible. For some licenses, the way in which the combination is made may affect whether they are compatible—for instance, they may allow linking two modules together, but not allow merging their code into one module.

If you just want to install two separate programs in the same system, it is not necessary that their licenses be compatible, because this does not combine them into a larger work. The other license is compatible with the GPL if it permits this too. GPLv3 is compatible with more licenses than GPLv2: it allows you to make combinations with code that has specific kinds of additional requirements that are not in GPLv3 itself. Section 7 has more information about this, including the list of additional requirements that are permitted.

If you do this, your program won't be fully usable in a free environment. If your program depends on a nonfree library to do a certain job, it cannot do that job in the Free World. If it depends on a nonfree library to run at all, it cannot be part of a free operating system such as GNU; it is entirely off limits to the Free World. So please consider: can you find a way to get the job done without using this library? Can you write a free replacement for that library?

If the program is already written using the nonfree library, perhaps it is too late to change the decision. You may as well release the program as it stands, rather than not release it.

But please mention in the README that the need for the nonfree library is a drawback, and suggest the task of changing the program so that it does the same job without the nonfree library.

Please suggest that anyone who thinks of doing substantial further work on the program first free it from dependence on the nonfree library. Note that there may also be legal issues with combining certain nonfree libraries with GPL-covered free software.

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.

If you want your program to link against a library not covered by the system library exception, you need to provide permission to do that. In either case, you should put this text in each file to which you are granting this permission.

Only the copyright holders for the program can legally release their software under these terms. If you wrote the whole program yourself, then assuming your employer or school does not claim the copyright, you are the copyright holder—so you can authorize the exception. But if you want to use parts of other GPL-covered programs by other authors in your code, you cannot authorize the exception for them.

You have to get the approval of the copyright holders of those programs. When other people modify the program, they do not have to make the same exception for their code—it is their choice whether to do so. If the libraries you intend to link with are nonfree, please also see the section on writing Free Software which uses nonfree libraries.

If you're using GPLv3, you can accomplish this goal by granting an additional permission under section 7. The following license notice will do that. You must replace all the text in brackets with text that is appropriate for your program. If not everybody can distribute source for the libraries you intend to link with, you should remove the text in braces; otherwise, just remove the braces themselves. If you modify this Program, or any covered work, by linking or combining it with [name of library] or a modified version of that library , containing parts covered by the terms of [name of library's license] , the licensors of this Program grant you additional permission to convey the resulting work.

If you're using GPLv2, you can provide your own exception to the license's terms. Again, you must replace all the text in brackets with text that is appropriate for your program. Linking [name of your program] statically or dynamically with other modules is making a combined work based on [name of your program]. In addition, as a special exception, the copyright holders of [name of your program] give you permission to combine [name of your program] with free software programs or libraries that are released under the GNU LGPL and with code included in the standard release of [name of library] under the [name of library's license] or modified versions of such code, with unchanged license.

Note that people who make modified versions of [name of your program] are not obligated to grant this special exception for their modified versions; it is their choice whether to do so. The GNU General Public License gives permission to release a modified version without this exception; this exception also makes it possible to release a modified version which carries forward this exception.

Under the Berne Convention, everything written is automatically copyrighted from whenever it is put in fixed form. However, registering the copyright in the US is a very good idea. It will give you more clout in dealing with an infringer in the US. The case when someone else might possibly claim the copyright is if you are an employee or student; then the employer or the school might claim you did the job for them and that the copyright belongs to them.

Whether they would have a valid claim would depend on circumstances such as the laws of the place where you live, and on your employment contract and what sort of work you do. It is best to consult a lawyer if there is any possible doubt. If you think that the employer or school might have a claim, you can resolve the problem clearly by getting a copyright disclaimer signed by a suitably authorized officer of the company or school.

Your immediate boss or a professor is usually NOT authorized to sign such a disclaimer. Many universities nowadays try to raise funds by restricting the use of the knowledge and information they develop, in effect behaving little different from commercial businesses.

If you see any chance that your school might refuse to allow your program to be released as free software, it is best to raise the issue at the earliest possible stage. The closer the program is to working usefully, the more temptation the administration might feel to take it from you and finish it without you. At an earlier stage, you have more leverage. But the copyright holder for a program can release it under several different licenses in parallel.

The license that comes in your copy, assuming it was put in by the copyright holder and that you got the copy legitimately, is the license that applies to your copy. To release a nonfree program is always ethically tainted, but legally there is no obstacle to your doing this. If you are the copyright holder for the code, you can release it under various different non-exclusive licenses at various times. Strictly speaking, the GPL is a license from the developer for others to use, distribute and change the program.

However, if the developer does something that would violate the GPL if done by someone else, the developer will surely lose moral standing in the community. No, because the public already has the right to use the program under the GPL, and this right cannot be withdrawn. Yes, because the copyright on the editors and tools does not cover the code you write. Using them does not place any restrictions, legally, on the license you use for your code.

Some programs copy parts of themselves into the output for technical reasons—for example, Bison copies a standard parser program into its output file.

In such cases, the copied text in the output is covered by the same license that covers it in the source code. Meanwhile, the part of the output which is derived from the program's input inherits the copyright status of the input. As it happens, Bison can also be used to develop nonfree programs. This is because we decided to explicitly permit the use of the Bison standard parser program in Bison output files without restriction. We made the decision because there were other tools comparable to Bison which already permitted use for nonfree programs.

Yes, you do. Since you don't need the developers' permission for such use, you can do it regardless of what the developers said about it—in the license or elsewhere, whether that license be the GNU GPL or any other free software license. If the program is written by US federal government employees in the course of their employment, it is in the public domain, which means it is not copyrighted. It can still be free software , however; a public domain program is free. However, when a US federal government agency uses contractors to develop software, that is a different situation.

GNU Ada was developed in this way. Or the contract can assign the copyright to the government agency, which can then release the software under the GNU GPL. If the improvements are written by US government employees in the course of their employment, then the improvements are in the public domain.

There is no problem in this situation. If the US government uses contractors to do the job, then the improvements themselves can be GPL-covered. Linking a GPL covered work statically or dynamically with other modules is making a combined work based on the GPL covered work. On the other hand, if you yourself convey the executable LGPLed library along with your application, whether linked with statically or dynamically, you must also convey the library's sources, in one of the ways for which the LGPL provides.

In general this is legally impossible; copyright law does not give you any say in the use of the output people make from their data using your program. If the user uses your program to enter or convert her own data, the copyright on the output belongs to her, not you.

More generally, when a program translates its input into some other form, the copyright status of the output inherits that of the input it was generated from. So the only way you have a say in the use of the output is if substantial parts of the output are copied more or less from text in your program.

For instance, part of the output of Bison see above would be covered by the GNU GPL, if we had not made an exception in this specific case. You could artificially make a program copy certain text into its output even if there is no technical reason to do so. But if that copied text serves no practical purpose, the user could simply delete that text from the output and use only the rest. Then he would not have to obey the conditions on redistribution of the copied text.

The output of a program is not, in general, covered by the copyright on the code of the program. So the license of the code of the program does not apply to the output, whether you pipe it into a file, make a screenshot, screencast, or video.

Programs that output audio, such as video games, would also fit into this exception. However, fair use may still apply.

So your module has to be available for use under the GPL. But you can give additional permission for the use of your code. The license list page gives a partial list of GPL-compatible licenses.

Yes, because the program actually links to the library. As such, the terms of the GPL apply to the entire combination. The software modules that link with the library may be under various GPL compatible licenses, but the work as a whole must be licensed under the GPL.

When the interpreter just interprets a language, the answer is no. The interpreted program, to the interpreter, is just data; a free software license like the GPL, based on copyright law, cannot limit what data you use the interpreter on.

You can run it on any data interpreted program , any way you like, and there are no requirements about licensing that data to anyone. So if these facilities are released under the GPL, the interpreted program that uses them must be released in a GPL-compatible way.

The JNI or Java Native Interface is an example of such a binding mechanism; libraries that are accessed in this way are linked dynamically with the Java programs that call them. These libraries are also linked with the interpreter. If the interpreter is linked statically with these libraries, or if it is designed to link dynamically with these specific libraries , then it too needs to be released in a GPL-compatible way.

Another similar and very common case is to provide libraries with the interpreter which are themselves interpreted. For instance, Perl comes with many Perl modules, and a Java implementation comes with many Java classes. These libraries and the programs that call them are always dynamically linked together. A consequence is that if you choose to use GPLed Perl modules or Java classes in your program, you must release the program in a GPL-compatible way, regardless of the license used in the Perl or Java interpreter that the combined Perl or Java program will run on.

You may link your program to these libraries, and distribute the compiled program to others. That means that you don't need to worry about including their source code with the program's Corresponding Source. GPLv2 provides a similar exception in section 3.

You may not distribute these libraries in compiled DLL form with the program. To prevent unscrupulous distributors from trying to use the System Library exception as a loophole, the GPL says that libraries can only qualify as System Libraries as long as they're not distributed with the program itself.

If you distribute the DLLs with the program, they won't be eligible for this exception anymore; then the only way to comply with the GPL would be to provide their source code, which you are unable to do. It is possible to write free programs that only run on Windows, but it is not a good idea.

Because it imposes a specific requirement that is not in the GPL; namely, the requirement on advertisements of the program. Section 6 of GPLv2 states:. You may not impose any further restrictions on the recipients' exercise of the rights granted herein.

GPLv3 says something similar in section The advertising clause provides just such a further restriction, and thus is GPL-incompatible. It depends on how the main program invokes its plug-ins. If the main program uses fork and exec to invoke plug-ins, and they establish intimate communication by sharing complex data structures, or shipping complex data structures back and forth, that can make them one single combined program. A main program that uses simple fork and exec to invoke plug-ins and does not establish intimate communication between them results in the plug-ins being a separate program.

If the main program dynamically links plug-ins, and they make function calls to each other and share data structures, we believe they form a single combined program, which must be treated as an extension of both the main program and the plug-ins.

Using shared memory to communicate with complex data structures is pretty much equivalent to dynamic linking. Please see this question for determining when plug-ins and a main program are considered a single combined program and when they are considered separate works. If the main program and the plugins are a single combined program then this means you must license the plug-in under the GPL or a GPL-compatible free software license and distribute it with source code in a GPL-compliant way.

A main program that is separate from its plug-ins makes no requirements for the plug-ins. Please see this question for determining when plug-ins and a main program are considered a single combined program and when they are considered separate programs. If they form a single combined program this means that combination of the GPL-covered plug-in with the nonfree main program would violate the GPL.

However, you can resolve that legal problem by adding an exception to your plug-in's license, giving permission to link it with the nonfree main program. See also the question I am writing free software that uses a nonfree library. If they form a single combined program then the main program must be released under the GPL or a GPL-compatible free software license, and the terms of the GPL must be followed when the main program is distributed for use with these plug-ins.

However, if they are separate works then the license of the plug-in makes no requirements about the main program. Not exactly. It means you must release your program under a license compatible with the GPL more precisely, compatible with one or more GPL versions accepted by all the rest of the code in the combination that you link.

The combination itself is then available under those GPL versions. You can ask, but most authors will stand firm and say no. The idea of the GPL is that if you want to include our code in your program, your program must also be free software.

It is supposed to put pressure on you to release your program in a way that makes it part of our community. Does distributing a nonfree driver meant to link with Linux violate the GPL? Yes, this is a violation, because effectively this makes a larger combined work. The fact that the user is expected to put the pieces together does not really change anything. Each contributor to Linux who holds copyright on a substantial part of the code can enforce the GPL and we encourage each of them to take action against those distributing nonfree Linux-drivers.

Add this text to the license notice of each file in the package, at the end of the text that says the file is distributed under the GNU GPL:. Note that people who make modified versions of ABC are not obligated to grant this special exception for their modified versions; it is their choice whether to do so. If you modify the ABCDEF interface, this exception does not apply to your modified version of ABC, and you must remove this exception when you distribute your modified version.

Only the copyright holders for the program can legally authorize this exception. To answer this question, we would need to see a list of each component that your program uses, the license of that component, and a brief a few sentences for each should suffice describing how your library uses that component. Two examples would be:. The GPL permits you to create and distribute an aggregate, even when the licenses of the other software are nonfree or GPL-incompatible. The only condition is that you cannot release the aggregate under a license that prohibits users from exercising rights that each program's individual license would grant them.

Where's the line between two separate programs, and one program with two parts? This is a legal question, which ultimately judges will decide. We believe that a proper criterion depends both on the mechanism of communication exec, pipes, rpc, function calls within a shared address space, etc. If the modules are included in the same executable file, they are definitely combined in one program. If modules are designed to run linked together in a shared address space, that almost surely means combining them into one program.

By contrast, pipes, sockets and command-line arguments are communication mechanisms normally used between two separate programs. So when they are used for communication, the modules normally are separate programs. But if the semantics of the communication are intimate enough, exchanging complex internal data structures, that too could be a basis to consider the two parts as combined into a larger program.

No, the analysis of whether they are a single work or an aggregate is unchanged by the involvement of containers. Our lawyers have told us that to be in the best position to enforce the GPL in court against violators, we should keep the copyright status of the program as simple as possible. We do this by asking each contributor to either assign the copyright on contributions to the FSF, or disclaim copyright on contributions.

We also ask individual contributors to get copyright disclaimers from their employers if any so that we can be sure those employers won't claim to own the contributions. Of course, if all the contributors put their code in the public domain, there is no copyright with which to enforce the GPL. So we encourage people to assign copyright on large code contributions, and only put small changes in the public domain.

If you want to make an effort to enforce the GPL on your program, it is probably a good idea for you to follow a similar policy. It is possible to make modified versions of the GPL, but it tends to have practical consequences. You can legally use the GPL terms possibly modified in another license provided that you call your license by another name and do not include the GPL preamble, and provided you modify the instructions-for-use at the end enough to make it clearly different in wording and not mention GNU though the actual procedure you describe may be similar.

For this purpose we would want to check the actual license requirements to see if we approve of them. Although we will not raise legal objections to your making a modified license in this way, we hope you will think twice and not do it. Such a modified license is almost certainly incompatible with the GNU GPL , and that incompatibility blocks useful combinations of modules. The mere proliferation of different free software licenses is a burden in and of itself.

Thus, for instance, you must make the source code available to the users of the program as described in the GPL, and they must be allowed to redistribute and modify it as described in the GPL. These requirements are the condition for including the GPL-covered code you received in a program of your own.

The GPL defines this as the preferred form of the work for making changes in it. However, for manuals and textbooks, or more generally any sort of work that is meant to teach a subject, we recommend using the GFDL rather than the GPL. See this article for details. It works as designed, intended, and expected.

Nothing required Y to agree to any other license for its code. Therefore, X must get Y's permission before releasing that code under another license. You cannot incorporate GPL-covered software in a proprietary system. The goal of the GPL is to grant everyone the freedom to copy, redistribute, understand, and modify a program.

If you could incorporate GPL-covered software into a nonfree system, it would have the effect of making the GPL-covered software nonfree too. A system incorporating a GPL-covered program is an extended version of that program. This is for two reasons: to make sure that users who get the software get the freedom they should have, and to encourage people to give back improvements that they make. However, in many cases you can distribute the GPL-covered software alongside your proprietary system.

To do this validly, you must make sure that the free and nonfree programs communicate at arms length, that they are not combined in a way that would make them effectively a single program. The substantive part is this: if the two programs are combined so that they become effectively two parts of one program, then you can't treat them as two separate programs.

So the GPL has to cover the whole thing. If the two programs remain well separated, like the compiler and the kernel, or like an editor and a shell, then you can treat them as two separate programs—but you have to do it properly.

The issue is simply one of form: how you describe what you are doing. Why do we care about this? Because we want to make sure the users clearly understand the free status of the GPL-covered software in the collection. But if they know that what they have received is a free program plus another program, side by side, their rights will be clear. But if you were to incorporate them both in a larger program, that whole would include the GPL-covered part, so it would have to be licensed as a whole under the GNU GPL.

You can distribute it the GPL code , provided you make your source available. You don't have to. You could modify it, but when you distribute your application you are obliged to make your source available and also the source for the modifications you made to the library.

If your application is not distributed with the GPL code and you make users download it separately to make use of it, then your case is a little bit more special and might provoke some argument, but the same principle will most likely ultimately apply: you must make your source available.

If you want to avoid these problems then you need to use things with a different license or at the very least the LGPL which will allow run-time calling of libraries without the viral-spread of the GPL conditions back to your code.

When in doubt you need legal advice. Any advice you get here from me or anyone else should be treated fairly carefully. Only a lawyer can give you proper legal advice. This very strongly seems to disagree if you are using it on a website, rather than re-distributing an executable:. You can distribute your application using a GPL library commercially, but you must also provide the source code. If you distribute this library in an executable, you must disclose your source code by providing it either alongside your distribution or list an accessible way URL, physical copy to obtain the source for 3 years.

Does not apply if you serve through a web portal. Disclaimer : I am not a lawyer and I haven't read either version of the GPL in a while, so this answer might be legally inaccurate. This is the impression given for version 2; version 3 may be different. I'm not clear on how that affects your product's licensing. That might be distribution.

Tell your employees not to distribute the software. So if they do, they are committing copyright infringement, not you. If you distribute the software with source code then you have fulfilled all your obligations. Nobody can ask you for anything. If you distribute the software with a promise to deliver the source code, anyone in the world can ask for the source code. If you use GPL code at runtime, you gotta give out the source.

If you give out a prebuilt developer environment docker image, etc , that counts as distributing and you have to make all the gpl-using code also open source We can force such rules in the jungle, but in real life juridical of country or state it depends on who, whom, when and what. GPL program is infecting and infected the parent and the child non GPL process proprietary and even other open source license from the perspective of law. No problem exists when you compile a distributed GPL source as act individual person, org, company.

Sign up to join this community. The best answers are voted up and rise to the top. Stack Overflow for Teams — Collaborate and share knowledge with a private group.

An obvious spin on copyright, copyleft uses copyright laws to enforce the open-source status of software. Language in GPLv3 makes it much more comprehensive to address technical and legal changes, including international license exchange clauses.

GPLv3 provides specific terms for combined works, which may apply when other source code, components, or libraries accompany the GPL software. The complete license agreement clearly defines when every condition applies and when developers can waive that clause.

It also has definitions to help users understand the boundaries of components used in larger works, including how to evaluate what clause to follow when a user is unsure. To release software under GPL licenses, users need to obtain a copyright disclaimer from any superseding entity like an employer or school.

Once the disclaimer is in place, each file should receive the proper copyright notices while clearly defining what versions users can use. Adding the copyright notice display at startup is optional. Developers should keep in mind that GPL intends to prevent any additional restrictions on the software. When using any portion of GPLed software, the modified version retains the same rights. As such, the user should release the updated source to subsequent users only if the user releases the modified software to the public.