I looked at a number of other licensing questions and did not find anything that I felt related to this particular issue.

I am working on a simple web app, nothing special, and intend to license it with the MIT license. The foundation for this app was generated using Clementine.js (here is the GitHub repo). Clementine.js contains its own MIT license with the copyright holder listed as the person who developed the boilerplate.

My confusion/concern comes from the following points:

  • I must maintain the MIT license for Clementine.js
  • Clementine.js is built in such a way that it is not a library or package, it is a foundation that you build from
  • I would like to license the final product under my own MIT license

I am pretty unfamiliar with licensing practices and, in this situation, I am not sure how to proceed. I have read a number of similar licensing questions and a lot of them pertain to libraries/packages having individual licenses that can be bundled within that library/package's sub-directory. In this case, the licensed boilerplate code will inextricably be part of the final product.

Should I:

  • Merge the two licenses into a single license, putting myself and the Clementine.js copyright holder on the same license?
  • Create a single license file containing two separate licenses, one for the final product with a mention indicating it was built off of Clementine.js and then provide the Clementine.js copyright and license agreement?
  • Create two separate license files (LICENSE.md and LICENSE.ClementineJS.md)?

Any other possible solutions are welcome; I am out of my depth when it comes to licensing.

1 Answer 1


IANAL, but the case you describe is IMHO similar to the distinction between licenses for individual modules of a software and the software "as a whole", as you often find them in open source software. For example, though the Linux kernel is licensed under GPL, it contains parts or modules which have a different (compatible) license (like libc, which is under LGPL). You will typically find different license texts in separate files for such a case.

The MIT license reads "... The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. ...", but it does not contain any requirement to put the copyright text into a file named "LICENSE.md".

Putting this together leads to

  • you have to add the original, unmodified copyright notice from Clementine.js somewhere to your programs docs (so this rules out any kind of "merge" where the original text is modified)

  • you should have a clear license distinction between the final program "as a whole" and the license of "Clementine.js"

  • the license you use for the final program must be "compatible" with the MIT license (it must not contain anything which contradicts the licenses of any of its parts or "foundations")

If you achieve this by creating two separate license files, or by writing both license texts into one file, does not really matter, there is nothing in the MIT license saying the text must be kept in a separate file. Mentioning in your license text that the final product was built off of Clementine.js is a good idea for both cases, independently from the decision for one or two files.

  • Thanks for taking the time to respond. I would argue that this scenario and the Linux scenario you describe are entirely different. In your scenario, the modules are isolated and distinct. For my scenario, there is no clear distinction; the original software/code from Clementine.js will be modified/removed/added to and there is no way to dictate "this piece belongs to me, that piece belongs to Clementine." Dec 29, 2015 at 0:11
  • Overall, I think that one license file with two separate copyrights and mentioning that the product was built off Clementine.js is the best solution but I am waiting for other replies before marking this as the answer. Dec 29, 2015 at 0:17
  • @minustehbare: the difference is IMHO not so big as you might think. Consider the following: whenever you use a library, lets assume a LGPL or MIT licensed, and you link this lib statically into a bigger program, a combined product is formed where the modules are afterwards not distinct and isolated any more. In case of boilerplates, the merge is not done by a linker program, but "manually" by a person, but from a viewpoint of licensing this should not make a real difference.
    – Doc Brown
    Dec 29, 2015 at 6:45
  • That explanation helps. I think that, personally, I have trouble seeing past the fact that the library is still a standalone product that is being leveraged and not modified. I concede your point, however; marking as answer. Dec 29, 2015 at 22:26

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.