Yzena Network License 0.1
This license is a draft. Do not use.
This license gives users as much permission to work with this software as possible, while protecting contributors from liability and ensuring that anyone who makes this software part of any software available for public use publishes their changes.
In order to receive this license, you must agree to its rules. The rules of this license are both obligations under that agreement and conditions to your license. You must not do anything with this software that triggers a rule that you cannot or will not follow.
In this license, the phrase “source code” includes the original material licensed under this license.
In this license, the phrase “this software” includes the source code. It also includes the output of any execution of any algorithm that uses all or part of this software as all or part of its input, but only if the output itself is software.
Each contributor licenses you to do everything with this software that would otherwise infringe that contributor’s copyright in it, except anything that would break any rule of this license.
Unless any contributor says otherwise, this software can be relicensed under all later versions of this license.
If you wish to make any part of this software part of any software that is available for public use, and if you made any changes to the source code, you must provide the source code, and you must do so under this license or any of the licenses under Compatibility. However, this rule need not apply to the rest of any software for which this software is only a part, including any parts of the software that this software needs.
You must ensure that everyone who uses any software that includes any part of this software, with or without changes, gets the text of this license or a link to https://yzena.com/yzena-network-license.
If the source code includes a file named
NOTICE.md, then you
must ensure that everyone who uses any software that includes or uses all or
part of this software, with or without changes, also gets the verbatim text of
This License does not grant you any rights to the names, trademarks, service marks, or logos of any contributors.
You cannot initiate any patent litigation claiming that this software infringes any patent, directly or indirectly.
If any contributor notifies you in writing that you have not complied with Distribution, Notices, Credits, Trademarks, and/or Litigation, you can keep your license by taking all practical steps to comply within 30 days after the notice. If you do not do so, your license ends immediately after the 30 days.
Each contributor licenses you to do everything with this software that would otherwise infringe any patent claims they can license or become able to license.
No contributor can revoke this license from you unless you do not follow its rules.
As far as the law allows, this software comes as is, without any warranty or condition, and no contributor will be liable to anyone for any damages related to this software or this license, under any kind of legal claim.
Frequently Asked Questions
What is the Yzena Network License?
It is a permissive network copyleft license.
No, it’s explicitly not viral. In my opinion, virality is parasitic and has caused people to use closed-source software instead of FOSS alternatives when those alternatives were licensed under the AGPL.
Who are you? And are you a lawyer?
No, I am not a lawyer, but most of this license is taken from the Blue Oak Model License 1.0.0 (BOML), which was written by lawyers.
Why did you choose the BOML to start with?
What is the list of changes you made from the BOML?
Besides changing the link to the license in the Notices section, these are the changes I made:
- Added to the Purpose section about publishing changes for any public use.
- Added the Source Code section.
- Added the This Software section.
- Added the Compatibility section.
- Added the Distribution section.
- Added the Credits section.
- Added the Trademarks section.
- Added the Litigation section.
- Changed the Excuse section such that any contributor has to give notice of non-compliance, instead of anyone.
- Added references to the Distribution, Credits, Trademarks, and Litigation sections in the Excuse section.
- Tweaked the Reliability section.
If you mostly copied the BOML, why shouldn’t I just use that one?
You actually should, if all you need is a typical permissive license, then yes, you should use the BOML.
However, this is a network copyleft license, so if that’s what you need, then the YNL might work for you. Be sure to consult with your lawyer first.
Why do you use such vague language and don’t define some of your terms?
Your Credits section doesn’t actually require giving credit.
No, it doesn’t. But it does require providing the verbatim text of the
NOTICE.mdfile, and I assumed that the contributors would add whatever credits they wanted in there.
You also don’t require giving a link to the original project, if someone makes changes and relicenses the code.
No, but I also assumed that the original contributors would put that information in the
NOTICE.md, and that text must be provided verbatim.
That assumption simplified the license, which makes things easier on contributors and users.
It made it easier to write the license and will make it easier to comply with the license.
More concretely, the Apache 2.0 License uses the phrase “NOTICE file.” I decided to avoid that awkward language.
And while I could have chosen any file format, Markdown is text, easily readable, well-supported (with ways to convert it), and should have all of the features that would be needed for such a file.
The Credits section says that it is required to provide the verbatim text of the
NOTICE.mdfile. Why didn’t you just require people to provide the file?
Because if someone makes changes to the software, I wanted them to be able to add their own credits to the
NOTICE.mdfile, which they can do by adding theirs at the bottom or the top of the original, since the verbatim text of the original will still be intact.
What do you suggest putting in the
I suggest adding these things:
- The name of the original software.
- A link to the original code/repository.
- A link to the Yzena Network License to tell users that they can get the original under that license if they wish.
- The (preferred) names of all contributors that want credit.
Why do you care about patents and trademarks?
Because I want to be able to make a business based on Open Source software, and I do not want to have to worry about losing trademarks or possibly getting sued for patent infringement.
Also, software patents are, in my opinion, illegal because you can’t patent algorithms. They have also never been used for actual innovation, which makes them useless.
Why did you not use a sunset clause, like copyleft-next? That seems like a good idea.
It is a good idea, since the term of copyright is much longer than it should be.
However, unlike movies or other works of art, software is constantly changing. So if there was such a sunset clause in YNL, it might be ambiguous whether or not the clause applies to all of the software, or just those portions that have existed as long as the sunset term.
Why did you not use a nullification of copyright clause, like copyleft-next, to prevent proprietary dual licensing?
While that clause is also a good idea, its purpose is also somewhat fulfilled by the Reliability clause.
Why did you use the vague phrase “make…this software…part of any application that is available for public use”?
I intentionally wanted to make the requirement for sharing source kick in for every public use of the YNL-licensed software, whether direct or indirect. I want code to be shared, first and foremost.
Obviously, if a company makes a public-facing webapp that uses YNL-licensed software, that is making it available for public use, and they should be expected to share their changes, if any.
However, if YNL-licensed software is used only as part of private infrastructure, there is no expectation to share changes.
Also, this definition has some other good side effects: it includes software used on things like arcade machines and software included on OEM machiens as well, among other things.
Yes, if YNL-licensed software is used in an arcade machine available in a public arcade, that is covered under this definition, as is any software that comes preinstalled on computers or phones sold by manufacturers.
Where do you draw the line “part of an application available for public use”?
My line is best illustrated with an example.
Say I write database software and license it under the YNL. If a company makes a publically available webapp that stores data in my database, even if that database also holds data for their non-public monitoring system, I would consider that the database is part of the publically available webapp, and they should share changes.
However, if the company does not use my database to store data for the webapp, but only uses it to store data for their non-public monitoring systems, then that would not be part of the publically available webapp, and they do not need to share changes.
What’s with the weird definition for “this software”?
GitHub Copilot. I want the YNL to poison the well for machine learning like that.
However, even though the training is supposedly fair use, that doesn’t mean that the distribution of the output of such algorithms is fair use.
The definition of “this software” is crafted to exploit this discrepancy.
But maybe the output of the algorithm is under fair use as well.
If it is, then copyright disappears entirely from software. The reason for this is that we already use algorithms to transform our software. We call those algorithms “compilers,” and their output “executables” or “libraries.” No one claims that a source code’s copyright does not apply to the binary forms output by a compiler.
What if the output of a machine learning algorithm is transformative? Would that not be enough to defeat copyright?
A compiler’s output is also transformative, especially if it does optimizations. This especially applies if the compiler is doing link-time optimization using inlining with code from different sources. In that situation, a compiler is combining multiple sources in non-obvious ways, just as machine learning models do.
A compiler can even transform an
O(n)algorithm into an
In other words, unless GitHub Copilot wants to throw out copyright on software completely, this license will apply to the output of its model.
Why didn’t you just add a clause protecting the output of machine learning?
The reason why it does is because the AGPL allows distribution of binary code, and what is binary code but the output of an algorithm (the compiler) whose input is the source code of the software covered by the AGPL?
If I decide to abandon AGPL compatibility, however, I still think I will keep the definition because it is wonderfully broad in a way that is best for end users.
Your extra restrictions make your license incompatible with the AGPL.
I don’t think so.
First, they are not extra restrictions; they codify something that I believe already exists in the AGPL and friends.
Second, even if they are extra restrictions (which would make this license incompatible with the AGPL), I think I am okay with that.
In fact, if my licenses are not compatible with the AGPL and friends, then I will keep the terms I have and accept the incompatibility. I can do this because these licenses will mostly be used for code in a new language, which means that I wouldn’t be able to use existing code easily anyway.
Your extra restrictions make your license non-Open Source.
Once again, I don’t think so, and for why, see above. The new parts are not new restrictions; they are clarified.
But even if the license is non-Open Source, I’m not sure I care.
The reason is this: I believe FOSS licenses have failed. We have so many companies that have used the freedoms we have tried to give users in order to extract value (data or something else) unethically from those very users. They do this by claiming the rights of distribution that the FOSS licenses give them and then using those rights to distribute Open Source software to users in such a way that they don’t realize that they are being taken advantage of.
The more I’ve understood that, the more I have come to realize that the current iteration of FOSS licenses do not work.
But what will work?
Remember how I said that companies claim the rights of distribution we give them? As it turns out, end users, so-called because they are at the end of a chain of distribution, don’t usually use distribution rights.
That means that the next generation of FOSS licenses can probably more heavily restrict how licensed software is distributed while allowing for no restrictions on the other two freedoms of the four freedoms.
I’m not ready to go that far yet. If I was, I’d add a clause forbidding ads in the software. But that is probably the sort of direction we need to go.
I carefully defined “source code” to ensure that was not the case.
You see, while the license does apply to the entire output, the requirement is still to provide only the source code of the original. There is no requirement to provide the source code of the entire software, as there is with the AGPL.
Why did you say that “this software” only includes output of algorithms that is itself software?
Technically, you can run software through things like hash functions, which are algorithms, and the output is entirely unusable as software. Saying that the license would apply to output like that would never work.
The same goes for static analysis tools. They don’t usually output something that can be considered “software”; instead, they output a list of problems with the software. I wouldn’t want that to be affected by this license.
In other words, that little part of the definition is required from making the definition so broad that it becomes useless.
Your definition of “this software” has “this software” in the definition.
That’s because the definition is recursive. The base case is the source code of the software, and then whenever the source code, or the result of transforming “this software” is transformed by an algorithm, the definition recursively applies.
Why did you define “source code”?
Because of the recursive definition of “this software”. See the previous question.
Why did you write this FAQ when nobody has asked you any questions yet?
To establish intent. If these licenses have to be tested in court, then if my intent is clear, that can help judges and juries resolve ambiguities and decide if a license violation happened.
The AGPL did the same thing. However, in that case, the license includes the intent in the Preamble to the license, which muddies the waters. The reason for this is because if the Preamble conflicts with another part of the license, which part wins?
To stop that from happening, I set forth my intent in this FAQ, but I also explicitly made it a separate document (in the repository). That way, if the FAQ conflicts with the license, the license wins hands down.