Can i use gpl for commercial purpose

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. The fact that proprietary module A communicates with GPL-covered module C only through Xlicensed module B is legally irrelevant; what matters is the fact that module C is included in the whole. The exception is meant to allow people to distribute programs compiled with GCC under terms of their choice, even when parts of these libraries are included in the executable as part of the compilation process.

There are two reasons for this. First, a general one. If we permitted company A to make a proprietary file, and company B to distribute GPL-covered software linked with that file, the effect would be to make a hole in the GPL big enough to drive a truck through. This would be carte blanche for withholding the source code for all sorts of modifications and extensions to GPL-covered software. Giving all users access to the source code is one of our main goals, so this consequence is definitely something we want to avoid.

More concretely, the versions of the programs linked with the Money Guzzler libraries would not really be free software as we understand the term—they would not come with full source code that enables users to change and recompile the program. If the license of module Q permits you to give permission for that, then it is GPL-compatible.

Otherwise, it is not GPL-compatible. If the license for Q says in no uncertain terms that you must do certain things not compatible with the GPL when you redistribute Q on its own, then it does not permit you to distribute Q under the GPL.

So you cannot link or combine P with Q. The whole point of the GPL is that all modified versions must be free software —which means, in particular, that the source code of the modified version is available to the users.

The general rule is, if you distribute binaries, you must distribute the complete corresponding source code too. The exception for the case where you received a written offer for source code is quite limited. Version 3 of the GPL allows this; see option 6 b for the full details.

Under version 2, you're certainly free to offer source via FTP, and most users will get it from there. However, if any of them would rather get the source on physical media by mail, you are required to provide that.

Yes, you can. The offer must be open to everyone who has a copy of the binary that it accompanies. This is why the GPL says your friend must give you a copy of the offer along with a copy of the binary—so you can take advantage of it.

Section 6 d allows this. However, you must provide clear instructions people can follow to obtain the source, and you must take care to make sure that the source remains available for as long as you distribute the object code. No, you must supply the source code that corresponds to the binary.

Corresponding source means the source from which users can rebuild the same binary. Part of the idea of free software is that users should have access to the source code for the programs they use. Those using your version should have access to the source code for your version. A major goal of the GPL is to build up the Free World by making sure that improvement to a free program are themselves free.

This is a well-meaning request, but this method of providing the source doesn't really do the job. A user that wants the source a year from now may be unable to get the proper version from another site at that time. The standard distribution site may have a newer version, but the same diffs probably won't work with that version.

If you make object code available on a network server, you have to provide the Corresponding Source on a network server as well. The easiest way to do this would be to publish them on the same server, but if you'd like, you can alternatively provide instructions for getting the source from another server, or even a version control system.

No matter what you do, the source should be just as easy to access as the object code, though. This is all specified in section 6 d of GPLv3. The sources you provide must correspond exactly to the binaries. In particular, you must make sure they are for the same version of the program—not an older version and not a newer version.

You don't have to make sure of this. As long as you make the source and binaries available so that the users can see what's available and take what they want, you have done what is required of you. It is up to the user whether to download the source. Our requirements for redistributors are intended to make sure the users can get the source code, not to force users to download the source code even if they don't want it. Complete corresponding source means the source that the binaries were made from, but that does not imply your tools must be able to make a binary that is an exact hash of the binary you are distributing.

In some cases it could be nearly impossible to build a binary from source with an exact hash of the binary being distributed — consider the following examples: a system might put timestamps in binaries; or the program might have been built against a different even unreleased compiler version. The GPL permits anyone to make a modified version and use it without ever distributing it to others. What this company is doing is a special case of that. Therefore, the company does not have to release the modified sources.

Compare this to a situation where the web site contains or links to separate GPLed programs that are distributed to the user when they visit the web site often written in JavaScript , but other languages are used as well. In this situation the source code for the programs being distributed must be released to the user under the terms of the GPL. The GNU Affero GPL requires that modified versions of the software offer all users interacting with it over a computer network an opportunity to receive the source.

What the company is doing falls under that meaning, so the company must release the modified source code. No, in that case the organization is just making the copies for itself. As a consequence, a company or other organization can develop a modified version and install that version through its own facilities, without giving the staff permission to release that modified version to outsiders.

However, when the organization transfers copies to other organizations or individuals, that is distribution. In particular, providing copies to contractors for use off-site is distribution. If the version has been released elsewhere, then the thief probably does have the right to make copies and redistribute them under the GPL, but if the thief is imprisoned for stealing the CD, they may have to wait until their release before doing so.

GPLv3 also allows developers to add local disclaimers, which also helps increasing its usage outside the US. The new language used in the GPLv3 establishes this even more clearly.

There is, however, an issue with the original BSD license as it imposes a specific requirement that is not in the GPL the requirement on advertisements of the program. LGPL is used to license free software so that it can be incorporated into both free and proprietary software.

You are only obliged to subject your modifications to the original free library to the LGPL. Since the free library is always subject to the LGPL, it must be possible for any user of your software to modify, recompile or replace the free LGPL library and use its modified version with your software. You are also required to permit or note prevent reverse engineering of the work that uses the library in order to enable debugging when the LGPL library is modified replaced with later versions.

If a developer modifies a program released under the GPL, he is expected to release the modified program under the same license, but if this program runs on a server only, the developer is not really releasing it to the rest of the world. The AGPL covers this case. Under the AGPL, the developer must release the modified version of the program to everyone who uses the service. So, these are ten of your top GPL License questions answered. The GPL won't infect your proprietary software unless you link to it.

Distributing in this sense means giving or selling to customers. If you're just using a distributed multi-node system inside your company, then you're entirely in the clear, as yan says.

Incidentally, the GPLv2 v3 here is written to be read by non-lawyers. I strongly recommend you take a look at it. If English isn't your first language, translations are available in many languages. Haproxy is GPLv2, so you can redistribute it in binary form provided you give enough information to the end user about where to fetch the sources to rebuild it. When you have a doubt on those points, keep in mind that the GPL's goal is to ensure that if you disappear, your customers will not be left with a buggy software they can't fix.

So you just have to provide them means not to depend on your availability. When you keep that in mind, it's a lot easier to make the right choice. And good faith always counts if you try to make this possible but fail because you've not thought about everything. Also, keep in mind that whenever you start distributing software, some of your customers will ask for specific changes to better cover their needs.

At first you'll refuse but after losing a few customers who all want the exact same minor feature, you'll accept. Then you'll have patched the code and be embarrassed because you won't be able to point the customer to the original site to get the code. There are two approaches to this : - the patch is of general use and you don't want to maintain it. Just submit it for inclusion into mainstream. However, clause 4 adds the following protection for end-users of the proprietary program:.

However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. However, possible legal consequences for the proprietary developer who has breached the GPL may include:.

Such consequences have proven rare, at least in part because it is expensive to pursue legal remedies and there is little financial incentive.

Many GPL projects are non-commercial enterprises comprised of volunteers across multiple countries. However, organisations such as the FSF and other free software groups have taken on some cases as a matter of principle and to defend the integrity of open source licensing.

Remedying a GPL licensing issue could be achieved by replacing the relevant code with a suitable non-copyleft open source alternative for example, code licensed under the Apache, MIT or BSD licences [9] or acquiring a commercial licence if one is available.