RUNE LANGUAGE COPYRIGHT This software is (c)Copyright 1993-2016 by Matthew Dillon. Use of this code and binaries produced by this code are governed by the following stipulations: (1) All files making up the Rune distribution are defined as "the product" and subject to these terms. (2) There are two Rune Language licenses: A commercial license, and a free license. The license you need depends on the conditions under which you use this program. Most open-source programmers and users will fall under the free license. The free license, when applicable, does NOT require registration or a signed contract. Commercial licenses are negotiated on a case-by-case basis. (3) All uses of the product are governed by these copyright terms PLUS the license terms under the appropriate license. WITHOUT A LICENSE, YOU HAVE NO RIGHTS AT ALL TO USE OR MODIFY THIS PRODUCT. IF THE LICENSE IS DEEMED WHOLELY INVALID, YOU HAVE NO RIGHTS AT ALL TO USE OR MODIFY THIS PRODUCT. (4) NON TRANSFERABILITY: Unless otherwise stated, licenses are non-transferable. This means that it applies to you and does not automatically transfer to the people you distribute your product to. In order to use the product you have distributed, those people will be subject to the same copyright terms and MAY OR MAY NOT qualify for their own separate, free, unregistered license. (5) This copyright notice, applicable licenses, copyright notices in all distributed source code and documentation, and copyright notices embedded in object code and binaries, must be retained at all times, even when codebase modifications are allowed. In particular, the copyright and license must be retained and readily accessible in the directory tree containing the the files it applies to. If you are managing code with a repository (for example, git), the copyright and license must also be retained in the repository. (6) Any documentation referencing this work must refer to or contain this copyright notice and the following acknowledgement: "This product includes software developed by Matthew Dillon and contributors.". --------------------------------------------------------- The "FREE" Rune Language License (when applicable) Synopsis: This license is designed to support and promote an open-source and open-use environment while still protecting the author's interests in preventing misuse. All use of this distribution not covered by this license requires a negotiated commercial license. (1) There are distinctions between using this product, porting modifications, enhancement modifications, integrations, and redistributions. This license may be used for these purposes in the limited fashion covered in the clauses below. Clause (1) covers binary derived works (below). Clause (2) covers using the product. Clause (3) covers porting modifications. Clause (4) covers enhancements. Clause (5) covers integrations. Clause (6) covers packaging systems. When you write a program in Rune, intermediate, library, and binary files will contain some copyrighted Rune code simply by being linked against the rune core and the runtime will also have dynamic library dependencies against the rune core. You are granted a perpetual, non-revocable license to be able to run such binaries as well as to distribute such binaries and the related run-time support infrastructure commercially or non-commercially, as long as your application is not substantially similar to the Rune product itself (e.g. not used to simply wrap our product, with or without enhancement). Your own wholely written source files and the derived program binary itself is yours, you can copyright and license them as you wish. The specific elements of Rune embedded in these files (such as the Rune grammar) are not yours, but operate under a perpetual license which allows your program binary to use them. (2) Using Rune is defined as downloading, compiling, installing, and then using the Rune binaries and libraries to write your own applications in the Rune language. Just as with most computer languages, installing and using the rune environment is unrevocably free and covered by the free license. (3) Porting modifications. Any commercial or non-commercial entity can make modifications to the Rune distribution for the purpose of porting the distribution to an architecture under the following stipulations. * If you distribute your modifications or anything derived from your modifications, including binaries, you agree to make all such modifications available in patch or GIT form as an internet-accessible publically available patch or GIT repo, and: * You agree to relinquish all the rights releaseable under your country's law to said modifications such that anyone else can use your modifications, including any recopyrighting and relicensing, almost as if they were in the public domain. In return, anyone using your modifications agrees to attribute them to you. A GIT commit message in the repo is considered sufficient, and if the modification is significant enough the person using your modifications (under his sole discretion) may also add the author of the modification to the contributors list at the top of the file. The Rune copyright holder (Matthew Dillon) will specifically use this release to integrate patches into the main distribution under the Rune copyright. * If the law does not allow the degree of freedom required to allow others to use modifications as stipulated, then you may not make modifications under this clause. * Contributions to the project are assumed to be made as a good faith donation as stipulated above. For example, if a patch is mailed to us, posted on a public forum, or integrated into any open-source distribution. We assume these to be contributions that fall under these stipulations. If you do this mistakenly and do not wish to contribute the material, within a reasonable period of time of 6 months or as allowed by law from when you published it, you must notify us and we will withdraw it from the public. Your only recourse is that it be withdrawn from the HEAD of the repo and no longer used in ongoing distributions down the line. The repo history will remain intact. * The author of any modifications stipulates that they are entirely his own work and that he or she agrees to the terms of the license. If multiple authors, that all authors have read and agree to the terms of this license. * These stipulates remain in effect whether the copyright holder of the product (Matthew Dillon) decides to integrate the modifications into the base distribution or not. * Again, as a clarification, you cannot apply your own license or copyright to modifications, even whole-file modifications. In the open-source world, authors typically name themselves in source files via a copyright line near the top of the file. We wish to allow authors to include their names in source files but it cannot be done with a copyright line. Instead, you may add your name in comments near the top of a source file using the following example form: /* * Contributor - Charlie Chan - bug fixes */ or (if Rune code) # # ... other contributors ... # Contributor - Charlie Chan - bug fixes # (4) An 'enhancement' is defined to be the addition of any new feature to Rune. As a clarification, features include optimizations, grammar changes, additions to the core classes, and anything else that adds functionality to the Rune language that isn't a simple patch for porting purposes or bug fix to existing functionality. This clause is meant to control the open-source forking problem that can quickly destroy portability (particularly for a language), and indeed can destroy the whole project. Enhancements can be made with the following stipulations: * All stipulations in section (3). * Your enhancements are being made with the intent of getting them back into the core distribution. The copyright holder and core team for Rune have final say on whether features and enhancements go in or not. We will probably say 'no' a lot, we do not want Rune to become a kitchen-sink language and complex features have to be extremely well-tested before they can be considered for inclusion. On the otherhand, there is a huge amount of work that needs to be done especially on the core classes. * You cannot fork the project, meaning you can't take rejected enhancements and start your own project up to support them. That said, we need and expect contributors to maintain their own GIT repos with all their work. Theoretically these repos are a fork of a sort, but there is a big difference between using a repo to hold side branches in a supporting role and using copies of the repo in a primary role. We distinguish between these two use cases. Using copies of the repo in a supporting role is fully supported and allowed by this clause. * SUNSET CLAUSE FOR FORK RESTRICTIONS - The restriction on forking the project will be lifted on December 31 2018. The project forking stipulation above will no longer be applicable and can be removed on that date. (5) We consider an 'integration' of our product to be any situation where a substantial portion of the functionality of our product, such as being able to parse, compile, assemble, link, or interpret a Rune program (including JIT compilation), is repackaged into some other distribution not under our (the copyright holder, Matthew Dillon's) control. Integrations are governed by the following stipulations: * Integration into any non-commercial open-source product is allowed, defined as any product governed by the BSD or any GPL license whos controlling entity is not also distributing (or associated with an entity distributing) a proprietary form of the product. For example, Rune could be integrated into most linux distributions under this clause. * Integration into any commercial product or by any commercial entity who distributes a proprietary form of an open-source product requires a commercial license. The Free license may not be used in this case. * A commercial license is required for any other integration of Rune. Also, keep in mind that this license is not transferable so any users of your distribution must separately qualify for the free license or obtain their own. (6) Packaging. Any packaging system which packages the core Rune distribution, unenhanced, with only porting modifications which follow clause (3), may use this license to generate the port, maintain a copy of the sources, and build and host binary distributions. (7) LIMITED-REVOKABILITY of the FREE license by Matthew Dillon. This clause exists to protect the integrity of the Free License for both the licensee and the copyright holder, protecting both sides from extreme levels of liability should a conflict arise. This clause does NOT prevent the copyright holder (Matthew Dillon) from filing a lawsuit based on copyright law, but it does say in writing what the intent of the copyright holder is and any judge is expected to take that into account. By using this software the licensee is agreeing to the terms and conditions of this license. The Free license is not revocable when used in good faith. However, situations may arise where the licensee does not act in good faith. The copyright holder (Matthew Dillon) reserves the right to revoke the free license if he believes the licensee is not using it in good faith. Upon notification, the licensee is no longer able to use the Free license and must immediately stop using the product. If the licensee stops using the product and does not contest the revocation the conflict is considered resolved. The licensee has the right to contest the revocation by posting bond within 30 days at the going rate (as determined by the mediation company chosen by the copyright holder) for a licensed mediator to resolve the conflict. If the revocation is not contested within the time limit the mediation option is taken off the table and the copyright holder (Matthew Dillon) may resort to a lawsuit. If bond is posted within the time limit or as otherwise agreed to by the copyright holder if past the time-limit, The copyright holder (Matthew Dillon) will then hire a licensed mediator who will then mediate the conflict within 30 days and render a final verdict. The question to the mediator is solely as to whether the free license was applicable to the licensee's use case or not, it is not meant to adjudicate royalties or other payments (though such conversations can occur directly between licensee and copyright holder). If the copyright holder wins the licensee pays for the mediation via the bond and the licensee agrees to stop using the product. If the licensee wins the bond is returned and the copyright holder (Matthew Dillon) pays for the mediation. Note that 'good faith' is a matter of interpretation. It is not meant to be a strict reading of the license, but it is meant to distinguish between honest mistakes and intentional actions. Of course, given notification of a mistake, an honest mistake can quickly turn into an intentional one if the licensee does not quickly address it. The mediator is asked to take this into account as well. Once revoked, the person or entity in question will no longer be able to use the Free license for Rune for any purpose, indefinitely, and must withdraw any products already distributed or sold using the license, and any future products. (8) LIMITED LIABILITY. THIS SOFTWARE IS PROVIDED BY MATTHEW DILLON AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATT DILLON OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. (9) Sunset provision for entire project. On December 31st 2030 the copyright on the official distribution will be replaced with the 2-clause BSD copyright in its entirely. This license will no longer be applicable at that time and instead of the almost-public-domain BSD license will become applicable, allowing the codebase to be used for virtually any purpose by virtually anyone, commercial or not. --------------------------------------------------------- Examples of Free vs Commercial use. These examples are meant to clarify the intent of our copyright and license. These examples are not part of the official copyright or license, but may be used by mediator or the courts for clarification. Generally speaking my goal is for Rune to be freely useable in open-source-friendly settings but I want a piece of the pie if a commercial entity integrates it into a commercial product. A commercial license is generally required when you wish to make proprietary modifications or extensions to Rune, or integrate Rune into a commercial product. If you aren't sure, assume that a commercial license is required. * Lets say you are FreeBSD or Debian and you wish to distribute Rune as part of the base system or as a package, including hosting copies of the repo and/or binary packages. The Free license will allow you to do so. Keep in mind that any patches you place in the ports system must adhere to clause (3). * Lets say you are a commercial CD printing outfit and wish to include Rune on one of your CDs, which you sell. The Free license will allow you to do so under clause (5)... that is, if the CD printing outfit is merely redistributing a wholely open-source product as a product and not distributing its own proprietary version of the product, then it may use clause (5). However if the CD printing outfit wants to sell both a fully-open-source and a proprietatry product, then a commercial license is required for both * Lets say you are a company that wishes to make proprietary modifications to Rune and sell the result. A Commercial license would be required. * Lets say you are a company that wishes to create proprietary extensions to Rune, for example by interfacing it to your own proprietary backend. We consider this an enhancement (even if it operates as a separate program) and not an application and you would need a commercial license. * Lets say you are a company that wishes to incorporate Rune into your proprietary commercial application in order to allow users of your application to write code in Rune via the application. We consider this a proprietary 'Integration' of our product and a commercial license would be required. * Lets say you are a company that uses Rune to develop an application. You can distribute binaries of your application without having to get a Rune Commercial License. * Lets say you want to rebrand Rune and sell the result. We consider this wrapping and a commercial license would be required. * Lets say you wish certain negotiated rights to be transfered to the end-user. Since the Free License is non-transferable you would need a commercial license to be able to grant your end-users negotiated rights. For example, if you want to give your end-users the right to make proprietary extensions to Rune libraries you would need a commercial license from us because the Free License does not provide any such right.