choosealicense.com: the Jekyll catalog behind GitHub's license chooser
A site to provide non-judgmental guidance on choosing a license for your open source project
At a glance
- What is it?
- choosealicense.com is not a service you install for your users. It is a Jekyll site and a YAML license catalog that GitHub vendors into Licensee, and this article covers what that means if you want to run it, fork it, or contribute a license.
- Who is it for?
- Adopt it as a reference and as a data source if you need SPDX-aligned license metadata with human-readable permissions, conditions and limitations, or if you want to run the site locally to preview a license addition. Do not adopt it if you need legal advice, or a comprehensive list of every license in existence, since the project states it is deliberately not comprehensive and its catalog covers a select set.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly HTML, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- github/choosealicense.com4,241 ★ · +39
| Repository | 2026-09-23 | 2026-11-15 |
|---|---|---|
| github/choosealicense.com | 4.2k | 4.2k |
39 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
What choosealicense.com actually is, and who it is for
The project describes itself as a site that provides "accurate, non-judgmental, and understandable information about popular open source licenses" so people can make informed decisions about projects they start, maintain, contribute to, and use. That framing matters more than it sounds. The site does not tell you which license is best. It lays out permissions, conditions and limitations side by side and lets you pick.
The audience is narrower than the homepage suggests. If you are starting a repository and need to pick a license, the hosted site answers that in a few clicks. If you are building tooling that needs license metadata, the repository is the interesting part: the catalog lives in `_licenses` as a Jekyll collection, and per the README it is regularly vendored into Licensee, the library GitHub uses for its license chooser, its license detection, its licenses API, and for displaying license descriptions and metadata. So the repository serves two consumers at once, a human reading a web page and a program parsing YAML.
The README is explicit that the catalog is not comprehensive. That is a stated goal, not an oversight: there are a very large number of licenses, and the project filters down to a small list of those that matter. If you arrive expecting every OSI-approved license, you will be disappointed by design.
The mechanism: YAML front matter, a rules file, and a build step
Each license is a single file in `/_licenses`. The file has YAML front matter describing the license's properties, and the body contains the license text in plain text. Required fields include `title` (the full name as specified by spdx.org), `spdx-id`, `description`, `how`, `using`, `permissions`, `conditions` and `limitations`. Optional fields include `featured`, `hidden`, `nickname`, `note` and `redirect_from`.
The rules themselves are not free text. They are stored as a bulleted list of names such as `include-copyright`, and each name resolves to a human-readable label and description defined in `_data/rules.yml`. The README gives the example of `include-copyright` mapping to the label "Copyright inclusion" and the description "Include the original copyright with the code". To add a new rule you add it to that file and reference it from the license. This is the part that keeps the site non-judgmental in practice: every license is described with the same vocabulary, so the comparison table is generated rather than hand-written.
There is a second layer that only matters if you consume the data downstream. The README documents auto-populated fields such as `fullname`, `login`, `email`, `project`, `description`, `year` and `projecturl`. When GitHub creates a repository from a license, it replaces those strings with values from the repository, which is how the copyright line gets filled in. If you vendor the catalog yourself, those placeholders are your responsibility.
One design constraint is worth calling out. The legal text of each license is never translated. Translations exist: the site is served in multiple languages with the default at the root and each other language under its own prefix such as `/fr/`, generated from the same source files via jekyll-polyglot. But only the interface and the non-legal summaries are translatable. That is the correct call, and it also means a translation contribution is smaller than it looks.
Running choosealicense.com locally
The README states that cmake and make are required, and gives platform-specific install commands. On macOS it points at Homebrew:
brew install make cmakeOn Linux or Ubuntu it uses apt-get:
sudo apt-get install make cmakeWith those in place, the documented sequence clones the repository recursively, runs a bootstrap script, then starts the server:
git clone https://github.com/github/choosealicense.com.git --recursive
cd choosealicense.com
./script/bootstrap
./script/serverThe README says to open `http://localhost:4000` in a browser. That port is the one the project documents, not a guess. If the bootstrap or server steps fail, the README does not troubleshoot them itself. It points at the official Jekyll documentation and a Jekyll guide on running as a non-superuser. That is a fair boundary: the project is a Jekyll site, and Jekyll problems are Jekyll's to solve.
The recursive clone flag is not decoration. The repository has a `.gitmodules` entry and a `license-list-XML` directory at the top level, so a non-recursive clone leaves you with an empty submodule and a build that behaves differently from what the README describes.
Where the catalog model breaks down
The strongest limitation is easy to forget: the site is not a substitute for reading the license. A YAML summary of permissions and conditions is a navigation aid. It compresses a document whose meaning depends on jurisdiction, on how the code is linked, and on facts the site cannot see.
The second limitation is coverage. Because the project deliberately keeps a small list, a license that is perfectly valid but uncommon will not appear. You would be maintaining your own rule set at that point, and the shared vocabulary that makes the site's comparisons useful stops applying.
The third is the contribution bar. The README points at CONTRIBUTING.md for adding a license, and the required `using` field demands a map of three notable projects with straightforward LICENSE files that Licensee can detect. That is a real constraint: a license with no widely known adopters is hard to add, regardless of its merits. It also means the catalog skews toward licenses that already have visible users, which is a reasonable editorial policy and a genuine filter.
Finally, there is no release process visible. The repository has no published GitHub releases. The site is built and deployed from GitHub Actions, and the README notes that jekyll-polyglot is not a GitHub Pages plugin, which is why deployment runs through Actions rather than Pages' built-in build. If you fork the site for your own deployment, that workflow is the thing you inherit, not a versioned artifact you can pin.
How it differs from SPDX and from Licensee
The obvious alternative for license metadata is the SPDX License List, and the relationship is complementary rather than competitive. The README states that the `title` field is the license full name specified by spdx.org and `spdx-id` is the short identifier specified by spdx.org. The repository even carries a `license-list-XML` directory. So choosealicense.com is not trying to replace SPDX as the authority on identifiers. It is trying to answer a different question: given a license, what does it let me do, what does it require of me, and what does it forbid?
Licensee is the closer comparison, and the difference is direction of flow. Licensee is a detection library: you point it at a repository and it tells you which license is present. choosealicense.com is the data source that detection is built on, and the README describes the catalog as regularly vendored into Licensee. If your problem is "which license is in this repository," you want Licensee. If your problem is "what are the trade-offs between these licenses, in language a contributor can read," you want this catalog. Using one where the other belongs produces either a detection tool with no data or a prose site with no scanning.
A third option is writing your own comparison table. The difference in approach is the shared rule vocabulary in `_data/rules.yml`. A hand-written table drifts, because each new license gets described in whatever words the author chose that day. The rules file forces every license through the same set of named permissions, conditions and limitations, which is why the site can render a consistent comparison at all.
Maintenance, licensing and what a fork inherits
The repository is not archived, and the last push was on 2026-10-30. The default branch is `gh-pages`, which is worth noting before you open a pull request against the wrong branch.
The project's own license is MIT, per the repository metadata and the `LICENSE.md` file at the top level. That covers the site's code and its prose. It does not relicense the license texts in `_licenses`, which are the licenses themselves, and it does not make the summaries authoritative. If you vendor the catalog into your own product, you are redistributing MIT-licensed material and should carry the notice; if you are relying on the summaries for compliance decisions, the MIT grant is not the relevant question. That is a boundary to check with your own counsel, not something this repository settles.
Upgrade cost is mostly a Jekyll problem. The repository pins a Ruby version via `.ruby-version`, a `Gemfile` and `Gemfile.lock`, and has a `.bowerrc` and `bower.json` at the top level, which suggests front-end assets are managed separately from the Ruby dependencies. A fork that only wants the YAML data can ignore all of it and read `_licenses` plus `_data/rules.yml` directly. A fork that wants the rendered site inherits the Gemfile, the bower setup, the polyglot plugin and the Actions deploy workflow together. The practical choice is between the data and the whole site.
Editorial conclusion
Adopt it as a reference and as a data source if you need SPDX-aligned license metadata with human-readable permissions, conditions and limitations, or if you want to run the site locally to preview a license addition. Do not adopt it if you need legal advice, or a comprehensive list of every license in existence, since the project states it is deliberately not comprehensive and its catalog covers a select set. Before contributing, verify three things in the repository itself: that your license title and spdx-id match the SPDX list, that you have three notable projects whose LICENSE files Licensee can detect, and that your rules reference entries that already exist in _data/rules.yml rather than inventing new ones.
Frequently asked questions
Is a GPL 3.0 license free?
The site's purpose is to describe what each cataloged license permits, requires and forbids rather than to price it, and the README lists permissions such as commercial use, modification, distribution and private use as separate rules that vary by license. The repository does not state a cost for any license, because the licenses in the catalog are not sold.
What are OSI licenses?
The README references opensource.org/licenses when describing the `hidden` field, which controls whether a license is neither popular nor fills out the spectrum of licenses from strongly conditional to unconditional.
Can I use a MIT License for free?
MIT is the license of choosealicense.com itself, per the repository metadata and `LICENSE.md`. For what the MIT license permits and requires in general, the site's catalog stores each license's permissions, conditions and limitations as rules in its YAML front matter, and those are what the comparison pages render.
Which license is free to use?
The project deliberately avoids that framing. Its stated goal is to be non-judgmental and to help you find a license that meets your goals, and the catalog encodes each license as a set of permission, condition and limitation rules rather than a recommendation. Which rules fit depends on what you want to allow and require.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/github-choosealicense-com)Star history chart for your README
[](https://hysenlabs.com/projects/github-choosealicense-com)Was this useful?