Which is the best license for my Open Source project? [closed] - open-source

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 7 years ago.
Improve this question
I am a web developer, and I don't have enough knowledge about software licenses. I wish to publish some of my works, and I need to select licenses for them. My software product is free of cost, but I have some restrictions on distribution/modification of the code.
It’s free of cost (but donations are acceptable).
The source code is freely available. You can use, customize or edit/remove code (as long as the basic nature of the software is not changed).
You don’t have any permission to change the product name.
There are some libraries and classes which are in a folder called “myname”. You don’t have permission to rename “myname”.
You can contribute any additions or modifications to my project, to the original source repository (the contributor’s name/email/site link will be listed in the credit file).
You can’t remove the original author’s name from the license.
You can put the license file or license code anywhere in the project file or folder.
You can redistribute this code as free or commercial software.
Are all these restrictions valid? Given these restrictions, which license should I use?
My main intention is to make the product more popular with free source code while ensuring the original author is not ignored. The product is open.
Thank you all; the above points are because of my lack of knowledge of license terms.
You can help me to correct or remove some of the above points. What I’m basically looking for is in the paragraph above.

I don't think the following are currently covered by any license I am familiar with:
Don't deviate from the basic nature of the software.
You can use/customize/redistribute as free or commercial, but you can't change the name.

I'd argue that while the product may be free and "source code available", that what you're describing is not "Open Source". Notably, you're not letting people fork and/or repurpose the code, both of which are main features of an Open Source code base.
By retaining copyright, no one can "take your name off" of your code, as they don't possess copyright, but not being able to rename the project, or change the names of folders, that's pretty extreme.
So, I would suggest you think through your motivations behind releasing the code and from where these restrictions originiate.

As others have noted, you have some rather odd requirements:
“Don’t deviate the basic nature of the software.” (Do you specify the “basic nature of the software” in the program itself, and are you going to argue in court over something so vague?)
“You don’t have any permission to change the product name.” (Usually, if anything, the opposite is required: if you change it, you have to change the name, so people don’t think that the modifications represent your work.)
“There are some libraries and classes which are in a folder called ‘myname’: you don't have permission to rename ‘myname’.” (Similar to the first, but more concrete — though I’m not sure what the point of this is.)
Based on these requirements, I think the license which fits most closely with your stated desires is the GNU Free Documentation License. As indicated by the title, it’s almost never used for source code of programs.
It is the only license I know of which allows you to prohibit users from changing or improving specific parts of the work. For example, I think you could say that the folder “myname” is an “invariant section” (note that I am not a lawyer, and this is not legal advice).
It’s not compatible with the GPL, and (the way you’d use it) it’s not DFSG-free. It’s rarely used for software, so distributors and contributors might have trouble understanding how to apply it. In short, you probably wouldn’t be making any friends with this route.

BSD license should cover this. I have chosen it for my open-source stuff too.

As written your requirements don't fit into any specific license out there (that I know of), and since you are not looking to make money, getting a lawyer to draft one would be rather expensive, and fundamentally counter-productive.
I suggest you look at licenses for different open source projects out there and see which one matches closely with what you want, and use that.

To get everything you want you will probably have to write your own license. This is not necessarily in your best interests. You are going to have to make a choice between popularity and control:
If you use an established license, you will have a very wide audience for your work, which will have a chance to become popular.
If you insist on certain restrictions (the name can't be changed) you will keep greater control, but you will lose potential users; because lots of organizations won't look at software with a nonstandard license.
Your requirements are very close to BSD, and not that different from MIT. I recommend you browse the popular licenses blessed by the Open Source Initiative and choose the one you feel is closest to your desires. I've checked your edits, and if you insist that I make a recommendation, for your wishes I recommend the Simplified BSD license. It's a good, popular license that is often used by developers who want their work to be very widely deployed.
If you ask people in a README file not to fork your software and change the name, as a matter of personal preference rather than licensing terms, most people will honor your wishes.

I think you will have a hard time finding an existing license to fit your needs because you seem to require two separate sets of permissions: a MIT-like set of permissions for the source in general, with the exception of a locked-down "myname" folder. You may be better off separating your code into two separate parts, each with a different license. The MIT license seems to fit your conditions for the bulk of the code (except for the "basic nature of the software" statement, I'm not sure what you mean by that). The MIT license requires the copyright statement bearing your name to be retained in all copies of the source, so this would address the concerns you bring up in your first edit. Depending on the particular reasons why you need to add special restrictions for the "myname" folder, you may have to write a custom license (you can take an existing one that's close and simply tweak it) that governs only that folder. Your entire project doesn't have to fall under a single license.
3) You don't have any permission to
change the product name.
You might be asking for problems with this one. If someone takes your code, enhances it, and releases it with the same name then you will have two very different programs out there with the same name. This is very confusing for potential users. Is the the original version? The version that was modified with a German-language interface? The version that has a fix for a specific bug? When they all have the same name, it's difficult to determine. If a user has a bad experience with a particularly buggy (or worse, virus-infected) derivative work, they will be unlikely to use any version of your software because it appears to be the same program as the buggy version.
I get the impression that you are mostly wanting to avoid having your work copied and completely re-branded without any acknowledgment of your involvement. I might suggest that instead of prohibiting name changes, require that derivative works reference your original product name (for example, "ShinyNewProgram - Powered By YourOriginalName"). Many open-source projects trademark their product names and a provision like your #3 would then be a violation of trademark law; the more common solution is to require a new name (to differentiate it from the original) and to require clear attribution of the original work.

Related

Licensing an open source project after reading code of a similar one

I recently contributed some code to an open source library/tool just before I realized that I'd like to re-write this project myself (different programming language and design choices). However, some aspects of the project are just like I would have done them myself or are simply worth "copying". Even if I tried really hard to forget about the original code -- most class names, constants and other stuff just are naturally named the same. The original project's license is AGPL.
Can I use a different license (e.g. MIT)? Which ones?
Will I have to mention the original project somewhere?
If so, where? And will I ever be allowed to remove the notice (maybe after the two projects have truly diverged after a few years of development)?
I am not a lawyer and this is probably not the correct venue for soliciting legal advice.
However, this is my take, as one FOSS contributor to another.
Generally speaking when you contribute to open source projects, you retain the copyright over the code that you wrote, and you release it under a license that permits everyone to use modify and distribute it.
Thus, you retain the right to relicense code that you so contributed under MIT or another license. That doesn't count as "stealing" the code and erasing the GPL license -- you were the original source and you retain the right to release what was originally yours again under a different license.
In some projects, the leaders may request that people DO transfer copyright, although its pretty rare I think. You should check the licensing statement to be sure. Unless there is something in writing somewhere saying that you explicitly agree to transfer copyright to them, then most likely you retained it.
You do not have the right to relicense other peoples work though. In cases where you modified someone elses code, contributing some changes to their class or something, you probably become joint owners, and at least I would not feel comfortable copying the part that they made and relicensing it without permission.
That's just the text of the code though. If you want to rewrite another program from scratch, using a similar high level plan but different execution, I don't think copyright will encumber you. Intellectual property law can still encumber you if some technique or method in the code is covered by a software patent. But it doesn't sound like that's the case here.
To avoid legal issues, sometimes companies / groups of people will use "clean room design" (https://en.wikipedia.org/wiki/Clean_room_design). But iiuc this is just done as a precaution to unambiguously head off any possible lawsuit -- the law does not require that you use such techniques just because you once looked at GPL code, iiuc.
For an example of this playing out, you can look at the history of the MinGW cross compiler project, and the mingw-w64 spin-off of it, which originally began because a private company wanted a version of mingw which supported 64-bit processors and other things, and so used clean room design to reverse engineer the project. The result of this was eventually made fully open source, but was not accepted back into the original mingw project and so there are now two projects. (Hope that this is a fair and impartial summary of the history.)
https://en.wikipedia.org/wiki/MinGW#History

BSD License: How to manage attribution and project name in a fork [closed]

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 have forked a BSD-licensed project and made significant rewrites. In terms of numbers of characters, around 70% of the code was now written by me. I want to respect the original author's copyright while also receiving attribution for my work. Originally I intended to ask the best way to do that, but I see that according to this question I can just duplicate the original author's copyright line in the license file and put in my name and the year(s) of my work. Cool.
Now my question has to do with this line:
Neither the name of the PROJECTNAME nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
My rewrites have involved a significant change to the scope and direction of the application. I felt it appropriate to change the name of the app to better represent what my fork is. So:
Is changing the name cool? I don't see anything in the license that would prohibit it.
How best to represent this in the license? Should I replace the old project name with the new one? Should I modify that line to say "neither the name of the OLDPROJECTNAME, the name of the NEWPROJECTNAME, nor the names of its contributors..."?
I understand that no one here is going to give legal advice! I'm just looking for some general guidelines and best practices from the open source community.
You can change the name of the project, of course, BSD license being one of the most permissive ever, after public domain maybe.
It's not cool to keep the old name since you rewrote most of the code. And not fair for the original dev team.
If you are familiar with GPL-based licenses, they mostly have some clauses to make mentioning original authors and keeping the license mandatory. With BSD style, those aren't a problem anymore.
My answers are:
Consider yourself being an author of a fork, derived from any initial software but now doing things differently.
I guess you can attach any license you want now, since YOU are the author. Not sure about that though.
I want to respect the original author's copyright while also receiving attribution for my work.
It's nice you want to, but actually it's even a must. If you don't respect the usage terms given under BSD you would not have the right to rewrite the code (which you already did).
There are multiple ways how you can make the licensing of a software visible, whichever you have with your software make clear:
What is the name of the work (to make it identifiable) and who is the author of it, when was it written.
As your software makes use of other software, make clear under which license that other software is, which software it is, by whom it has been written etc..
If you want to allow your own changes and extendings to be re-used upstream in the project you forked, you should choose the same license for your work.
I felt it appropriate to change the name of the app to better represent what my fork is.
Is changing the name cool? I don't see anything in the license that would prohibit it.
The original usage conditions don't forbid you to change the project name. As you actually forked it, it makes very much sense that you change the name. Even if it's PROJECTNAME-user1311904-fork only or a completely different name.
How best to represent this in the license? Should I replace the old project name with the new one? Should I modify that line to say "neither the name of the OLDPROJECTNAME, the name of the NEWPROJECTNAME, nor the names of its contributors..."?
Actually as outlined above you have two licenses. You have got your license (the main license) which is for "your" software. And then you write that part of your software is licensed as. Then the original terms of the software your forked from are listed (as you got them from the original author). So it's clear what the licensing of your software is.
If you want to document this really good, you should put everything under version control, so it's technically possible to obtain the information what the original code was and what your changes are. So it's absolutely safely documented with the version control system to which part which license/es apply/ies.

Choosing an opensource license for a library [closed]

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 thinking of a good opensource licence to choose for my project. I got a few requirements but I have a hard time choosing a license because a read some different things about some of them.
The project is a Java project that can calculate decompression schemes for scuba diving. I want this project to be opensource because a wrong decompression scheme can be lethal. Therefore feedback on the algorithms and source code is important for me. I don't make my own algorithms but I use various opensource algorithms that I implement in 1 Java library.
My requirements are:
I and other contributers to the project don't want to be responsible for wrong calculated decompression schemes due to bugs in the code, miss use of the code or any other way that resulted in wrong decompression schemes.
The library should be able to use on a website I plan to build without the need to publish the server side code of the website.
It's not allowed to make any profit of the library itself. Even not even the library is changed and republished. However I don't mind if people sell programs the make use of the library.
If people change the code than they should be forced to re publish the library with an opensource licence (Optional requirement).
I hope someone with a bit more knowledge of licenses can help me out.
Well, there are a couple of things I notice right off the bat here.
First off, you talk about needing to be able to do things with your own code. If you are the copyright holder, you can do pretty much anything you damn well please with your own code. The license is for other people, not for you.
Also, disclaiming any responsibility for what the code may do to other folks is pretty much boilerplate with any license.
That being said, I've found in my work I can get by with the use of only 3 different kinds of licenses, depending on my needs.
Full on GPL
Benifits:
Nobody can ever take any of the code propreitary (without coming to me for a relicense). They can still use it and charge people, but since they'd have to license the result GPL, that wouldn't be particularly practical. The reason is that any of their users could give away all the free copies they like.
The sources are avilable for anybody to contribute to, so I might not have to find and fix every damn bug and write every new feature myself.
Drawbacks:
None of the code is usable in a properitary app
I use this typically for stand-alone apps.
GPL with linking exceptions
This is basically what it says; GPL with an exception that meerly linking against (or #including) the code does not render the entire result GPL. Here's an example from the Classpath library.
Benifits:
Nobody can ever take the code itself proprietary.
The code can be used in a proprietary product without making the whole closed-source product open-source. Only the GPL-licensed stuff has to stay GPL.
Drawbacks:
The facility itself can never be expanded into a proprietary facility. Generally a plus in my book, but it does deter some people from using it.
I use this typically for helper facilities and API's .
Public Domain
This means anyone can do anything they like with this code, including making a tiny tweak, slapping their own copyright on it and calling it theirs.
Benifits:
Anybody can feel free to use it however they like.
Drawbacks:
No protection from the code getting "stolen" by a proprietary software seller.
Impossible to do in may jurisdictions (a permissive BSD I understand can be a good alternative there).
I use this when I'm publishing something incomplete that I really want someone else to take over, or when publishing something that is supposed to be a reference implementation for a standard library.
Now in a case like yours what I would do is either:
Use GPL with the linking exceptions for the library. That will allow everyone (including you) to use the library in a proprietary application, but the library itself will always stay Free.
Use GPL, and insist that contributions from others have their copyrights assigned back to you. This allows you full rights to make your own proprietary app using other people's contributions, and doesn't allow anyone else (including those contributors) that same right. Kinda cheesy in my book, and will probably discourage outside contributors. However, only the most successful Free Software projects get any outside contributors anyway. So it may not be that much of a loss.
It came to my attention recently that Bruce Perens (one of the founders of OSI) actually made a blog post a year earlier that made the exact same point. He picked two different licenses than I did for the latter two though. He picked LGPL for the intermediate license, which I think is a mistake on his part. However, he picked the Apache License 2.0 for the latter license, and I think he may have a point on that one. The benefit you get from using Apache over straight Public Domain is that you are better protected from patent lawsuits. That isn't something poor little me really has to worry about, but your company is a different matter entirely.
This impossible. You say you want an open source license that prohibits making money. However, one of the key requirements for being an open source license is not making any restrictions with respect to commercialization.
Ergo, a license like you describe it cannot possibly exist.
And here the standard answer: StackOverflow is a site for programming questions. We are programmers. Your question is a legal question. This means that all answers (including mine) will be, by definition, crap, since we don't know WTF we're talking about.
For legal questions, ask a lawyer.

Correctly Applying an Open Source License [closed]

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
My question consists of multiple points that are inherently related, I apologize for that. I tried splitting it up a little more, but I would keep repeating myself.
What exactly is required to apply an open source license to a code base that is my Intellectual Property?
A lot of Open Source projects include a full copy of the license somewhere in a root directory but do also have some sort of file header including a license description, disclaimer and a copyright notice. Is that really necessary or does it depend on the license type?
If someone else contributes changes to this file, does he need to be named in the copyright notice too?
Disclaimer
I am not a lawyer, so you should really consult with one to get absolutely correct answers here.
To the best of my knowledge...
Whenever you author something, whether it be code or anything else, you automatically become the copyright owner of that work (unless you've signed an agreement whereby it is "work for hire").
As the copyright owner, you can apply whatever license you like. The fact is that, if you don't give out a license, then no one has any right to use, copy, modify, distribute, etc. your coyrighted work. So, users need your license to have permission to use the project (if you don't give a license, it cannot, contrary to popular belief, be presumed public domain). So, you don't need to worry about people ignoring the license... if they can't point to a license where you grant them rights to use your software, as the copyright owner, you can sue them for using your copyrighted work without your express permission to do so.
It is typical in open source projects to place the license in a file named "LICENSE" or "COPYING" in the top-level directory of the project. I suggest that you stick to this convention, since that is where people will look for the license. It is also good to indicate what the license is on the project's website, so that people don't have to download your whole project before they know what the license agreement is.
It is not necessary to include a full copy of the license in each source code file, although this is fairly common practice. Keep in mind, though, that putting a full copy of the license (or at least some indication of copyright ownership and the name of the license, if it is a well-known license) in any header files that you install will avoid any confusion as to where the header files originated, so it is reasonable to do that.
If you own the project and others contribute in a fashion similar to "work for hire", then it is not necessary to name the contributors. However, you should make it explicit (and get a permanent record of an agreement from contributors) that you will remain the sole copyright owner of the project, despite contributions made. Otherwise, the contributors do have copyright ownership over the files/code that they contributed.
One last thing, not related to the question... I highly recommend that you avoid GPL and LGPL, and go for a more permissive license (e.g. MIT, New BSD, Simplified BSD), as the former will limit the adoptability of your code, and projects with more liberal licenses, if they do become adopted in the industry, have the potential to be backed by the industry (e.g. the Apache Foundation has strong industry support, because, unlike GNU/FSF which mistakenly views open source and closed source as enemies, sees them as collaborators, and so uses licenses that allow their projects to be widely adopted by the industry world).
Disclaimer: IANAL. That said, here are some random thoughts on the topic:
The term "Intellectual Property" bundles together many kinds of law: patent, copyright, trademark, and trade secrets, among others. Applying a license to a work you create will affect how your work can be used. Because each license allows for different uses of your code, how you apply the license is usually specific to which license you choose. For example, information about how to license your code under the Apache 2.0 license can be found at http://www.apache.org/licenses/. Note that projects managed by the Apache Software Foundation also require each contributor to grant the ASF copyright for the work. Granting of copyright is separate from the license.
I'd recommend reading Van Lindberg's "Intellectual Property and Open Source" to learn some terminology, and if you have significant commercial interests related to the code, spend a few hours with a lawyer.
Disclaimer: I am not a lawyer, the below is simply my understanding of OSS licensing. If I'm wrong, I'd appreciate any corrections.
Clearly state (on your project website, in source code, documentation, splash screen, about dialog, etc.) that the project is licensed under whichever license you select.
Considering the nature of open source, if a portion of your project is used in a different project owned by someone else (e.g. some useful utility class), having the "basics" of the license as part of your source code's header text makes it clear which license governs the use of that specific source file, and who owns the copyright on that portion of code in the project as a whole.
Yes, unless they have supplied you with documentation stating that they have transferred copyright to you (I believe some larger projects require contributors to do this?).
For an example of applying an OSS license to a project, see http://www.gnu.org/licenses/gpl-howto.html
A license is simply the rules you expect others to abide by if they do anything (use it, modify it, post it, make fun of it, whatever) with your code.
a) You can put what you want, but to be taken seriously, you may use a license that is already nicely written and accepted ... check opensource dot org /licenses/category for a (loong) list
b) To decide which type of license, check out this recent aricle: http://www.itbusinessedge.com/cm/community/features/guestopinions/blog/ringing-in-the-new-year-with-clean-intellectual-property/?cs=38892&page=1 . Common ones are GPL V2, LGPL, Apache, New BSD- check out the summary matrix on Page 2 of the article
c) make sure your software doesn't include code from other open source or 3rd party, otherwise you'll be claiming theirs as yours- not a good idea! There are tools you can use on trial basis to scan your code.
d) put the text of the license in a License.txt or Copyright.txt file in the folder. Also add a simple (or complex, if you wish) header to the source files as Kimvais mentions in the previous post.
Good luck.
Short non-lawyer answer;
Nothing except making it clear to anyone that you, the sole author of the code, license the code under whatever terms.
It is advisable to have the license file in the root directory. I would personally add in the "top comments" of all files the line Copyright 2010 <Your Name>. Released under <license name> in <Your country>. The last part is so that you can claim that the license was never meant to be interpreted under any other law than your local (so you can get a competent lawyer in your home country in the event that everything goes wrong)
I would say that this depends on the license you choose
For further info, read this book - or consult a lawyer with experience of software licenses.

How do you choose an open-source license? [closed]

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'm a software engineer, not a lawyer, and my university doesn't offer any courses geared toward licensing software. In fact, their law-related courses are lacking (but slowly growing in number). Where can I go to learn about open-source licenses and how to choose them?
There are lots described here:
http://www.gnu.org/licenses/license-list.html#SoftwareLicenses
The decision of which one to use can be political, but should ultimately be determined by your plans/desires for the software. If you want to ensure it is always free then choose GPL or another "Copyleft" license. If you don't mind some commercial use, choose another one that's compatible with that.
I almost always end up usign MIT or BSD (they're equivalent), since it
Is the most liberal license out there. It just says you're not responsible for any kind of trouble, and optionally forces people to include a copyright notice of your original work in derivatives.
It allows closed source derivatives, which is something I see as a good thing: companies sometimes don't have the possibility to do their work under the GPL (they may themselves use products or components from a third party with restricted licenses).
That, and the GNU/GPL bunch are generally extremists when you encounter them in the wild.
This can create endless discussion, but there is one tenet I would hold to whenever deciding what license to use: DON'T CREATE A NEW ONE!!
No matter how persuasive your legal guy's arguments that, because no current license exactly meets your project's unique needs, you should write your own, or even just "slightly modify" an existing one, treat him like a programmer coming to you arguing that he just HAS to use a GOTO statement because nothing else in the language will work.
Other advice:
Choose one which has major usage (see http://freshmeat.net/stats/#license)
See David A. Wheeler's discussion of why to choose a license compatible with the GPL - http://www.dwheeler.com/essays/gpl-compatible.html.
If you are looking for information regarding free and open source licenses a useful comparison chart: http://en.wikipedia.org/wiki/Comparison_of_free_software_licences
You could always just use the best one of all, the WTFPL. I use this on most of my school projects since they aren't that great anyways.
Wikipedia, of course, has basically all the information you would ever need to know. But the hard part is to know where to start. I'd recommend starting off by reading about the Apache License and the GNU GPL, which are two popular sides to the same story, each offering different freedoms to the people associated with the code.
But here it is in a nutshell: Apache License lets anyone do anything with your code, including taking it and using it in a closed source product. It gives whoever is taking the code the freedom to do what they want with it.
The GNU GPL, on the other hand, allows your code only to be used in a project that is also distributed under the GPL. In this case you might write some code and prevent a proprietary company from using your work. Here, you're giving freedom to the code itself that it will always be used for "free" purposes.
I'm slightly surprised to see no mention of the Open Source Initiative as a source of information about which open source licences exist. It probably doesn't do the comparisons, so the other sites are also worth checking.
More pragmatic reasons can also influence your choice of license - if you want to use a GPL library, you must use GPL yourself, or if you intend your software to be part of a larger project then you need to look at their requirements.
I've recently begun investigating the type of licensing to apply to a rather substantial piece of work. The number of choices and the content, restrictions (or not) and limitations of all the open-source licenses is bewildering. I've found a couple good links in the answers posted, but I didn't see anything pointing to the Open Source Initiative's alphabetical list of licenses, so I've included it here.
We had a similar dilemma. At our company we decided invest lots of time on a framework, with the eventual hope of releasing it to the open source community. The business is built using open source tools (apache, php, etc.), it was time to give back. We decided on an LGPL/MPL dual license. That way, we could incorporate fixes/improvements from the community, while still protecting applications (particularly ours) running on top of it from being forced to go open source as well.