Lgpl can i modify

But the result is always bound to be under the GPL license too. You can also combine GPL software with other software — as long as the combined work is licensed and distributed under GPL. The reasoning behind this is to promote open source. If a great library is only available under GPL it will force software that wants to use the library to be free and open source, too. It has now been reinterpreted to be read out as the Lesser General Public License.

I assume they mean lesser , as in less strong in forcing software to be open source. Applying LGPL to a library ensures that the library itself and any modified versions of it will remain open source. But it can be used by closed source software.

When I started the Kentor. AuthServices project, my intention was for it to be free to use for anyone in any setup. But I was also a bit concerned about SAML2 being an enterprise technology, where there were not any really good solutions on. So I wanted to place restrictions so that a big player in the field would not be able to take the AuthServices project, add features to it, and release it as a packaged product under their own brand.

Anyone including the big players is welcome to use and participate in the development of the project, but I want all development efforts to be channeled back to the community. This includes work that we are doing as assignments from our customers, too.

The library can be used by both open and closed source software, but the library itself is protected from theft. Go ahead! When the GPL was invented, the web was not what it is today.

If you wanted to offer someone to use a software back then you had to distribute the software by giving them something they could install on their own systems. The GPL ensured that anyone distributing the software also had to offer the source. This license is mainly applied to libraries. You may copy, distribute and modify the software provided that modifications are described and licensed for free under LGPL.

Derivatives works including modifications or anything statically linked to the library can only be redistributed under LGPL, but applications that use the library don't have to be. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library.

If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility other than as an argument passed when the facility is invoked , then you may convey a copy of the modified version:.

The object code form of an Application may incorporate material from a header file that is part of the Library. You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates ten or fewer lines in length , you do both of the following:.

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.