This page's content is sourced from the JSHint project repository. If you spot an error, please open an issue or (better yet) make a pull request!

2020 Relicensing

In August of 2020, the JSHint project maintainers relicensed the project. This was the culmination of a years-long effort where great care was taken to respect the practice of software licensing and the intent of all contributors. By summarizing the process followed by the maintainers, this document demonstrates the legitimacy of the change.

Origin: JSLint

The JSLint project was first made publicly available in 2002. It was distributed free-of-charge, but it was licensed with the so-called "JSON License" [1]. Code published under this license is not recognized as "free software" by the Free Software Foundation [2], nor is it recognized as "open source" by the Open Source Initiative [3] due to the following clause:

The Software shall be used for Good, not Evil.

After the initial release, JSLint's creator iteratively improved it through a series of patches to its one-and-only source code file. Throughout this time, the owner was the sole contributor to the project.

The fork

In 2011, another developer made improvements of their own and published the result as a new project named "JSHint" [4]. This was permissible under the terms of JSLint's license provided that the new project used the same license for the code it inherited.

The second developer continued to modify JSHint and also accepted contributions from others. To promote the maintainability of the source code, new features were occasionally introduced in distinct files that were designed to be included at runtime. Referred to as "modules," these files were made available under the terms of the MIT "Expat" license [5]. As automated tests were written and included in the project, they too were licensed under MIT "Expat."

In the years that followed, the JSHint project accepted direct code contributions from hundreds of developers. Many of these patches modified the original JSON-licensed file. Meanwhile, the author of JSLint permitted the Eclipse Foundation to relicense a version of JSLint using the MIT Expat license so that it could be included in their project named Orion [6].

Injecting a FOSS starting point

In 2013, a user of JSHint requested that the project be relicensed [7]. The JSHint maintainers obliged via the following procedure:

  1. Using the git version control software, they reverted all of the changes that were submitted to JSHint. (The resulting code was identical to JSLint at the moment JSHint was created.)
  2. They replaced the JSON-licensed version of the code with the MIT-licensed version published by the Eclipse Foundation. (The resulting code differed from JSLint only in the license header.)
  3. They re-applied all of the changes that were submitted to JSHint.

While this operation created an "alternate history" which demonstrated how JSHint could have been created as a free software project, it did not necessarily reflect the intentions of the contributors. JSHint did not at that time maintain a Contributors Licensing Agreement, so the maintainers did not have the authority to modify the terms under which the JSHint-specific patches were submitted.

To address this, the maintainers first introduced a Contributors Licensing Agreement ("CLA"). They ensured all subsequent contributors agreed to the terms of the agreement prior to accepting their patches. They contacted every contributor who had modified the JSON-licensed jshint.js file and requested they they sign the agreement. Although most responded by signing the agreement, a few refused and still others did not respond.


A full listing of the patches whose authors have not signed the CLA is available alongside this document in the JSHint project source code repository.

The maintainers reviewed each patch which could not be relicensed. Many involved non-substantive changes such as code comment amendments, spelling corrections, or the introduction of references to standardized APIs. Because these contributions did not meaningfully alter the behavior of the software, there could be no claim to ownership, so explicit permission to relicense was not necessary.

However, a total of six patches included non-trivial changes to jshint.js. The maintainers arranged for each of these to be re-written.

Three contributions were rewritten by four volunteers who never reviewed the implementation they were rewriting. The project maintainers prepared an alternate version of the project for each volunteer--one that omitted each patch that needed to be reimplemented.

Three additional contributions were rewritten by a JSHint project maintainer. The uniqueness of his work was verified by the other maintainers.

In all cases, correctness of the new implementation was verified by the project's existing automated tests (because as described above, their licensing was not subject to change).


With this work complete, every line of code in the JSHint project has been permitted by its contributor to be licensed using the MIT "Expat" license. The "alternate history" is available in a Git tag named relicensing-2020.

As of version 2.12.0, JSHint is a free software project.

[1] [2] Ibid. [3] [4] [5] [6] [7]