From 7eba3525808069c1fb017193e6a8b66e96298977 Mon Sep 17 00:00:00 2001 From: timlichtenberg Date: Fri, 5 Jun 2026 21:44:14 +0200 Subject: [PATCH 01/14] Add licensing and open development page Add a /license page to the framework site that sets out how PROTEUS and its modules are licensed, and our commitment to open, reproducible science. The page explains that the framework only ever includes fully open source code, that each module is an independent work which is optional and distributed separately, why PROTEUS uses Apache 2.0 and when permissive licenses are preferable, how Apache 2.0 works alongside GPL-3 modules, and our commitment to crediting the developers of the code we build on. It closes by inviting questions and discussion. --- _pages/license.md | 146 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 146 insertions(+) create mode 100644 _pages/license.md diff --git a/_pages/license.md b/_pages/license.md new file mode 100644 index 0000000..a2d7fe4 --- /dev/null +++ b/_pages/license.md @@ -0,0 +1,146 @@ +--- +title: Licensing and open development +subtitle: How PROTEUS and its modules are licensed, and our commitment to open, reproducible science +description: "The licensing philosophy of the PROTEUS framework: fully open source, modular and independently licensed components, why we use Apache 2.0, how it works alongside GPL-3 modules, and our commitment to crediting the developers of the code we build on." +permalink: /license/ +image: /assets/img/og-default.jpg +--- + +PROTEUS is built on the conviction that science is strongest when it is open. +Open source code can be read, checked, run, adapted, and improved by anyone, which makes the results that depend on it reproducible and the methods behind them transparent. +We see this not as an optional extra but as a basic requirement for software that sits at the heart of scientific work. +Every part of the framework is therefore released under a recognised open source license. + +We also believe that open development is the best way to build software that lasts. +PROTEUS grows through collaboration: contributions from research scientists, software engineers, students, and many others across institutions and countries. +Keeping the code open, and keeping the barriers to using and contributing to it low, is what allows that community to form and the science to move forward. + +## Open source, without exception + +PROTEUS will only ever support and include fully open source code. +We do not build on closed, proprietary, or source-unavailable components, and we do not plan to. +If a capability can only be provided by code that is not open, we would rather develop an open alternative than compromise on this principle. +This keeps the entire pipeline, from input data to published figure, inspectable end to end. + +## A framework of independent modules + +PROTEUS is a coupling framework rather than a single monolithic program. +The physics is divided across a set of modules, each of which handles one domain: the atmosphere, the mantle, outgassing, photochemistry, escape, stellar evolution, tides, or interior structure. +Each module is a complete, standalone program in its own right. +It can be developed, tested, run, and published independently, and it lives in its own repository under its own license. +The PROTEUS coupler orchestrates the exchange of boundary conditions between whichever modules are selected for a given simulation. + +Two consequences follow from this design, and both matter for licensing: + +- **Modules are optional and swappable.** No single module is required for the framework to function. You can exchange one atmosphere model for another, enable or disable tidal heating, or substitute a different interior model. The framework never depends on any one specific component. +- **Modules are distributed separately.** PROTEUS does not bundle or redistribute the modules. The released PROTEUS package contains only PROTEUS source code. Each module is obtained directly by the user from its own repository, installed alongside PROTEUS, and combined at run time on the user's own machine. + +Much of the value of PROTEUS lies in this integration work: bringing established codes together, extending them, and in many cases contributing improvements back to the projects they came from. + +## Licenses across the framework + +Different components carry different licenses, reflecting the choices of their authors. +The authoritative license for any component is always the one stated in its own repository. +Representative examples across the ecosystem: + + + + + + + + + + + +
LicenseTypeExamples
Apache 2.0Permissive (with patent grant)PROTEUS, AGNI, CALLIOPE, JANUS, ZEPHYRUS
MITPermissiveMORS, Zalmoxis
BSD 3-ClausePermissiveSOCRATES
GPL-3.0Strong copyleftVULCAN, FastChem, atmodeller, SPIDER
+ +PROTEUS itself, the coupling framework, is released under the [Apache 2.0 license](https://www.apache.org/licenses/LICENSE-2.0). + +## Why PROTEUS uses Apache 2.0 + +Apache 2.0 is a permissive license. +It lets anyone use, modify, and redistribute the code, including as part of a larger work under a different license, as long as attribution and the license notice are preserved. +Beyond the permissions shared by MIT and BSD, Apache 2.0 adds an explicit patent license from contributors to users, together with a patent retaliation clause. +For scientific software intended to be reused widely, that patent grant provides a layer of protection that the shorter permissive licenses do not. + +The deeper reason is reach. +A permissive license keeps the barriers to adoption as low as possible. +Researchers and institutions can build on PROTEUS, and integrate parts of it into their own pipelines, without being obliged to release their entire surrounding codebase under a copyleft license. +This matters in practice: some public research institutes, agencies, and companies restrict or prohibit the use of strong-copyleft code precisely because of that obligation. +A permissive license keeps the door open to the widest possible set of collaborators. + +There are situations where strong copyleft is the right choice, for example when the explicit goal is to ensure that every downstream user must in turn keep their derived code open. +For the core PROTEUS framework, whose purpose is to enable science and to be reused as broadly as possible, we judge that maximising reach and minimising friction is more important than enforcing that obligation downstream. +This is why we prefer Apache 2.0, and more permissive licenses generally, for the framework and for the modules we maintain. + +## How Apache 2.0 works alongside GPL-3 modules + +Some modules used by PROTEUS are released under the GPL-3.0 license. +Apache 2.0 and GPL-3.0 are compatible in one direction: Apache 2.0 code may be incorporated into a GPL-3.0 project, in which case the combined result is governed by the GPL, but GPL-3.0 code may not be incorporated into an Apache 2.0 project. +PROTEUS does not incorporate GPL-3.0 source code into its own code base, so this one-directional compatibility is respected. + +The framework relies instead on the modular, separately distributed design described above. +The GPL's strong copyleft obligations attach to the distribution of a combined work. +Because PROTEUS distributes only its own Apache 2.0 code, and each module is distributed separately by its own authors and obtained directly by the user, PROTEUS itself does not distribute a combined work that includes GPL-3.0 code. +The modules remain independent programs, each governed by its own license. + +We state this plainly so that anyone reusing the framework understands which terms apply. +When PROTEUS is run together with a GPL-3.0 module, the combined work assembled on your machine is, in the strictest reading, subject to the terms of that module's license. +Treating each repository's license as authoritative, and keeping the modules optional and swappable, means the framework can always be configured to match the licensing requirements of a given project or institution. + +## Permissive licenses are the norm in scientific software + +Permissive licensing is the established choice across the scientific software the research community relies on every day. +The foundational scientific Python stack, including [NumPy](https://numpy.org), [SciPy](https://scipy.org), [pandas](https://pandas.pydata.org), [Matplotlib](https://matplotlib.org), [scikit-learn](https://scikit-learn.org), and [Astropy](https://www.astropy.org), is released under the permissive BSD 3-Clause license. +Major frameworks such as [TensorFlow](https://www.tensorflow.org) and [JAX](https://github.com/jax-ml/jax) use Apache 2.0, the same license as PROTEUS. +Many of these tools, including Matplotlib, NumPy, and pandas, grew out of academia and became broadly useful in large part because their permissive licensing posed the fewest obstacles to adoption. +PROTEUS follows the same path. + +## Credit where it is due + +A permissive license sets out how code may be used; it says nothing about the credit owed to the people who wrote it. +We treat scientific credit as a separate and serious obligation, fully independent of licensing. +PROTEUS exists because of the work of the wider community, and many of its modules build directly on codes developed and published by others. + +We are committed to giving that work proper credit: + +- The documentation and code link to the relevant publications and repositories for every module, so the original work is easy to find and cite. +- Modules that wrap or extend an existing code point to the original project and its papers. +- Users of PROTEUS are asked to cite the manuscripts listed in the [bibliography](https://proteus-framework.org/PROTEUS/Reference/bibliography/), to state the code version used, and to include an acknowledgement. + +Our full guidance on citation, authorship, and acknowledgement is set out in the [contributing guidelines](https://proteus-framework.org/PROTEUS/Community/CONTRIBUTING/). + +## Questions and discussion + +Licensing in open source is a genuinely nuanced area, and reasonable people interpret parts of it differently. +We have set out our position here in the spirit of transparency, and we welcome questions, corrections, and discussion. +If you maintain a code we build on, are considering building on PROTEUS, or simply want to understand our approach better, please get in touch. + +You can reach us through [GitHub Discussions](https://github.com/orgs/FormingWorlds/discussions), open an issue on the relevant repository, or email [proteus_dev@formingworlds.space](mailto:proteus_dev@formingworlds.space). +We are always happy to talk this through. + + From 5837ec3a4fff19d80a428821531db05bdfc7a44b Mon Sep 17 00:00:00 2001 From: timlichtenberg Date: Fri, 5 Jun 2026 21:45:22 +0200 Subject: [PATCH 02/14] Add aragog to the GPL-3.0 examples on the license page --- _pages/license.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_pages/license.md b/_pages/license.md index a2d7fe4..092e1d2 100644 --- a/_pages/license.md +++ b/_pages/license.md @@ -51,7 +51,7 @@ Representative examples across the ecosystem: Apache 2.0Permissive (with patent grant)PROTEUS, AGNI, CALLIOPE, JANUS, ZEPHYRUS MITPermissiveMORS, Zalmoxis BSD 3-ClausePermissiveSOCRATES - GPL-3.0Strong copyleftVULCAN, FastChem, atmodeller, SPIDER + GPL-3.0Strong copyleftVULCAN, FastChem, atmodeller, SPIDER, aragog From 7583f4d4a370dc076a6749a03395e3bc8eda8a34 Mon Sep 17 00:00:00 2001 From: timlichtenberg Date: Fri, 5 Jun 2026 21:47:10 +0200 Subject: [PATCH 03/14] Expand the patent license explanation on the license page --- _pages/license.md | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/_pages/license.md b/_pages/license.md index 092e1d2..79c9cfc 100644 --- a/_pages/license.md +++ b/_pages/license.md @@ -61,8 +61,13 @@ PROTEUS itself, the coupling framework, is released under the [Apache 2.0 licens Apache 2.0 is a permissive license. It lets anyone use, modify, and redistribute the code, including as part of a larger work under a different license, as long as attribution and the license notice are preserved. -Beyond the permissions shared by MIT and BSD, Apache 2.0 adds an explicit patent license from contributors to users, together with a patent retaliation clause. -For scientific software intended to be reused widely, that patent grant provides a layer of protection that the shorter permissive licenses do not. +Where Apache 2.0 goes further than MIT and BSD is on patents, which those shorter licenses do not address at all. +Apache 2.0 includes an explicit patent grant: each contributor automatically gives every user a perpetual, worldwide, royalty-free license to any of their own patents that are necessarily infringed by the code they contributed. +In plain terms, a contributor, or the institution that employs them, cannot have their code accepted into the project and then later assert a patent against the people who use it. +The license also includes a patent retaliation clause: if a user starts patent litigation alleging that the software infringes one of their patents, the patent licenses that user received under Apache 2.0 are terminated. +Together these provisions close a gap that MIT and BSD leave open, where a contributor could grant the copyright permissions while quietly retaining patent rights over the same code, and they shield the project and its community from patent attacks. +For scientific software this certainty is worth having, because contributors come from many universities, research institutes, and companies, each with their own intellectual property policies and patent portfolios. +The explicit grant lets everyone who builds on PROTEUS, including other research groups and any downstream industrial or governmental users, rely on the methods implemented in the code without fear of a later patent claim from a contributor. The deeper reason is reach. A permissive license keeps the barriers to adoption as low as possible. From 96c47f25dab689a2718fbf7329ee96bb5a171e77 Mon Sep 17 00:00:00 2001 From: timlichtenberg Date: Fri, 5 Jun 2026 22:06:43 +0200 Subject: [PATCH 04/14] Refine license page accuracy and add it to site navigation Correct the description of how modules are distributed so it matches how PROTEUS actually packages its dependencies, soften the licensing claims where the position is a matter of interpretation, and fix the patent and Matplotlib wording. Repair two documentation links that pointed at 404 URLs, and add the License page to the main menu and footer. --- _data/settings.yml | 3 +++ _pages/license.md | 25 ++++++++++++------------- 2 files changed, 15 insertions(+), 13 deletions(-) diff --git a/_data/settings.yml b/_data/settings.yml index 54b014d..b4b44a4 100644 --- a/_data/settings.yml +++ b/_data/settings.yml @@ -44,6 +44,9 @@ menu_settings: - title: 'People & Contact' url: '/people' + - title: 'License' + url: '/license' + footer_settings: footer_tagline: PROTEUS framework for planetary evolution diff --git a/_pages/license.md b/_pages/license.md index 79c9cfc..9aa28cc 100644 --- a/_pages/license.md +++ b/_pages/license.md @@ -33,7 +33,7 @@ The PROTEUS coupler orchestrates the exchange of boundary conditions between whi Two consequences follow from this design, and both matter for licensing: - **Modules are optional and swappable.** No single module is required for the framework to function. You can exchange one atmosphere model for another, enable or disable tidal heating, or substitute a different interior model. The framework never depends on any one specific component. -- **Modules are distributed separately.** PROTEUS does not bundle or redistribute the modules. The released PROTEUS package contains only PROTEUS source code. Each module is obtained directly by the user from its own repository, installed alongside PROTEUS, and combined at run time on the user's own machine. +- **Modules are published by their own authors.** PROTEUS does not copy module source code into its own code base, and it does not re-host or relicense any module. The PROTEUS package contains only PROTEUS source code. Where a module is a Python package, PROTEUS names it as a dependency that the package manager retrieves from that module's own published release; other modules are fetched from their own repositories at install time. In each case the code comes from the module's own authors, under the module's own license, and is combined with PROTEUS at run time on the user's machine. Much of the value of PROTEUS lies in this integration work: bringing established codes together, extending them, and in many cases contributing improvements back to the projects they came from. @@ -61,11 +61,11 @@ PROTEUS itself, the coupling framework, is released under the [Apache 2.0 licens Apache 2.0 is a permissive license. It lets anyone use, modify, and redistribute the code, including as part of a larger work under a different license, as long as attribution and the license notice are preserved. -Where Apache 2.0 goes further than MIT and BSD is on patents, which those shorter licenses do not address at all. -Apache 2.0 includes an explicit patent grant: each contributor automatically gives every user a perpetual, worldwide, royalty-free license to any of their own patents that are necessarily infringed by the code they contributed. +Where Apache 2.0 goes further than MIT and BSD is on patents, which those shorter licenses do not cover with an explicit grant. +Apache 2.0 includes an explicit patent grant: each contributor automatically gives every user a perpetual, worldwide, royalty-free license to any of their own patents that are necessarily infringed by the code they contributed, whether on its own or in combination with the rest of the project. In plain terms, a contributor, or the institution that employs them, cannot have their code accepted into the project and then later assert a patent against the people who use it. The license also includes a patent retaliation clause: if a user starts patent litigation alleging that the software infringes one of their patents, the patent licenses that user received under Apache 2.0 are terminated. -Together these provisions close a gap that MIT and BSD leave open, where a contributor could grant the copyright permissions while quietly retaining patent rights over the same code, and they shield the project and its community from patent attacks. +Together these provisions close a gap that MIT and BSD leave open, where a contributor could grant the copyright permissions while making no express promise about their patents. They also shield the project and its community from patent attacks. For scientific software this certainty is worth having, because contributors come from many universities, research institutes, and companies, each with their own intellectual property policies and patent portfolios. The explicit grant lets everyone who builds on PROTEUS, including other research groups and any downstream industrial or governmental users, rely on the methods implemented in the code without fear of a later patent claim from a contributor. @@ -73,7 +73,6 @@ The deeper reason is reach. A permissive license keeps the barriers to adoption as low as possible. Researchers and institutions can build on PROTEUS, and integrate parts of it into their own pipelines, without being obliged to release their entire surrounding codebase under a copyleft license. This matters in practice: some public research institutes, agencies, and companies restrict or prohibit the use of strong-copyleft code precisely because of that obligation. -A permissive license keeps the door open to the widest possible set of collaborators. There are situations where strong copyleft is the right choice, for example when the explicit goal is to ensure that every downstream user must in turn keep their derived code open. For the core PROTEUS framework, whose purpose is to enable science and to be reused as broadly as possible, we judge that maximising reach and minimising friction is more important than enforcing that obligation downstream. @@ -87,17 +86,17 @@ PROTEUS does not incorporate GPL-3.0 source code into its own code base, so this The framework relies instead on the modular, separately distributed design described above. The GPL's strong copyleft obligations attach to the distribution of a combined work. -Because PROTEUS distributes only its own Apache 2.0 code, and each module is distributed separately by its own authors and obtained directly by the user, PROTEUS itself does not distribute a combined work that includes GPL-3.0 code. +Because the PROTEUS package contains only its own Apache 2.0 code, and each module is published separately by its own authors under its own license, it is our understanding that the PROTEUS package itself does not distribute a combined work that includes GPL-3.0 code. The modules remain independent programs, each governed by its own license. We state this plainly so that anyone reusing the framework understands which terms apply. -When PROTEUS is run together with a GPL-3.0 module, the combined work assembled on your machine is, in the strictest reading, subject to the terms of that module's license. -Treating each repository's license as authoritative, and keeping the modules optional and swappable, means the framework can always be configured to match the licensing requirements of a given project or institution. +When PROTEUS is run together with a GPL-3.0 module, the combination assembled on your machine is subject to the terms of that module's license, and we treat that license as authoritative for any such run. +Treating each repository's license as authoritative, and keeping the modules optional and swappable, means the framework can be configured to match the licensing requirements of a project or institution wherever a suitable alternative module is available for each role it needs. ## Permissive licenses are the norm in scientific software Permissive licensing is the established choice across the scientific software the research community relies on every day. -The foundational scientific Python stack, including [NumPy](https://numpy.org), [SciPy](https://scipy.org), [pandas](https://pandas.pydata.org), [Matplotlib](https://matplotlib.org), [scikit-learn](https://scikit-learn.org), and [Astropy](https://www.astropy.org), is released under the permissive BSD 3-Clause license. +Much of the foundational scientific Python stack, including [NumPy](https://numpy.org), [SciPy](https://scipy.org), [pandas](https://pandas.pydata.org), [scikit-learn](https://scikit-learn.org), and [Astropy](https://www.astropy.org), is released under the permissive BSD 3-Clause license, and [Matplotlib](https://matplotlib.org) under its own, equally permissive license. Major frameworks such as [TensorFlow](https://www.tensorflow.org) and [JAX](https://github.com/jax-ml/jax) use Apache 2.0, the same license as PROTEUS. Many of these tools, including Matplotlib, NumPy, and pandas, grew out of academia and became broadly useful in large part because their permissive licensing posed the fewest obstacles to adoption. PROTEUS follows the same path. @@ -112,14 +111,14 @@ We are committed to giving that work proper credit: - The documentation and code link to the relevant publications and repositories for every module, so the original work is easy to find and cite. - Modules that wrap or extend an existing code point to the original project and its papers. -- Users of PROTEUS are asked to cite the manuscripts listed in the [bibliography](https://proteus-framework.org/PROTEUS/Reference/bibliography/), to state the code version used, and to include an acknowledgement. +- Users of PROTEUS are asked to cite the manuscripts listed in the [bibliography](https://proteus-framework.org/PROTEUS/Reference/bibliography), to state the code version used, and to include an acknowledgement. -Our full guidance on citation, authorship, and acknowledgement is set out in the [contributing guidelines](https://proteus-framework.org/PROTEUS/Community/CONTRIBUTING/). +Our full guidance on citation, authorship, and acknowledgement is set out in the [contributing guidelines](https://proteus-framework.org/PROTEUS/Community/CONTRIBUTING). ## Questions and discussion -Licensing in open source is a genuinely nuanced area, and reasonable people interpret parts of it differently. -We have set out our position here in the spirit of transparency, and we welcome questions, corrections, and discussion. +Licensing in open source is nuanced, and reasonable people read parts of it differently. +We have set out our position here, and we welcome questions, corrections, and discussion. If you maintain a code we build on, are considering building on PROTEUS, or simply want to understand our approach better, please get in touch. You can reach us through [GitHub Discussions](https://github.com/orgs/FormingWorlds/discussions), open an issue on the relevant repository, or email [proteus_dev@formingworlds.space](mailto:proteus_dev@formingworlds.space). From c2ce9b40f49f6456e9ecdcf5bb6ba11e53fe16d2 Mon Sep 17 00:00:00 2001 From: timlichtenberg Date: Fri, 5 Jun 2026 22:29:29 +0200 Subject: [PATCH 05/14] Tighten wording on the license page Drop the absolute claims and filler phrasings, soften the one remaining flat licensing assertion, and acknowledge that domain-specific solver codes are often copyleft rather than implying permissive licensing is universal. --- _pages/license.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/_pages/license.md b/_pages/license.md index 9aa28cc..740f75c 100644 --- a/_pages/license.md +++ b/_pages/license.md @@ -32,7 +32,7 @@ The PROTEUS coupler orchestrates the exchange of boundary conditions between whi Two consequences follow from this design, and both matter for licensing: -- **Modules are optional and swappable.** No single module is required for the framework to function. You can exchange one atmosphere model for another, enable or disable tidal heating, or substitute a different interior model. The framework never depends on any one specific component. +- **Modules are optional and swappable.** No single module is required for the framework to function. You can exchange one atmosphere model for another, enable or disable tidal heating, or substitute a different interior model. - **Modules are published by their own authors.** PROTEUS does not copy module source code into its own code base, and it does not re-host or relicense any module. The PROTEUS package contains only PROTEUS source code. Where a module is a Python package, PROTEUS names it as a dependency that the package manager retrieves from that module's own published release; other modules are fetched from their own repositories at install time. In each case the code comes from the module's own authors, under the module's own license, and is combined with PROTEUS at run time on the user's machine. Much of the value of PROTEUS lies in this integration work: bringing established codes together, extending them, and in many cases contributing improvements back to the projects they came from. @@ -67,39 +67,39 @@ In plain terms, a contributor, or the institution that employs them, cannot have The license also includes a patent retaliation clause: if a user starts patent litigation alleging that the software infringes one of their patents, the patent licenses that user received under Apache 2.0 are terminated. Together these provisions close a gap that MIT and BSD leave open, where a contributor could grant the copyright permissions while making no express promise about their patents. They also shield the project and its community from patent attacks. For scientific software this certainty is worth having, because contributors come from many universities, research institutes, and companies, each with their own intellectual property policies and patent portfolios. -The explicit grant lets everyone who builds on PROTEUS, including other research groups and any downstream industrial or governmental users, rely on the methods implemented in the code without fear of a later patent claim from a contributor. +The explicit grant lets anyone who builds on PROTEUS use the methods implemented in the code without the risk of a later patent claim from a contributor. The deeper reason is reach. A permissive license keeps the barriers to adoption as low as possible. Researchers and institutions can build on PROTEUS, and integrate parts of it into their own pipelines, without being obliged to release their entire surrounding codebase under a copyleft license. -This matters in practice: some public research institutes, agencies, and companies restrict or prohibit the use of strong-copyleft code precisely because of that obligation. +Some public research institutes, agencies, and companies restrict or prohibit the use of strong-copyleft code precisely because of that obligation. There are situations where strong copyleft is the right choice, for example when the explicit goal is to ensure that every downstream user must in turn keep their derived code open. -For the core PROTEUS framework, whose purpose is to enable science and to be reused as broadly as possible, we judge that maximising reach and minimising friction is more important than enforcing that obligation downstream. +For the core PROTEUS framework, whose purpose is to enable science and to be reused as broadly as possible, we judge that making PROTEUS easy to adopt and reuse matters more than forcing that obligation on downstream users. This is why we prefer Apache 2.0, and more permissive licenses generally, for the framework and for the modules we maintain. ## How Apache 2.0 works alongside GPL-3 modules Some modules used by PROTEUS are released under the GPL-3.0 license. Apache 2.0 and GPL-3.0 are compatible in one direction: Apache 2.0 code may be incorporated into a GPL-3.0 project, in which case the combined result is governed by the GPL, but GPL-3.0 code may not be incorporated into an Apache 2.0 project. -PROTEUS does not incorporate GPL-3.0 source code into its own code base, so this one-directional compatibility is respected. +PROTEUS does not incorporate GPL-3.0 source code into its own code base, so this one-directional constraint does not arise for PROTEUS itself. The framework relies instead on the modular, separately distributed design described above. The GPL's strong copyleft obligations attach to the distribution of a combined work. Because the PROTEUS package contains only its own Apache 2.0 code, and each module is published separately by its own authors under its own license, it is our understanding that the PROTEUS package itself does not distribute a combined work that includes GPL-3.0 code. The modules remain independent programs, each governed by its own license. -We state this plainly so that anyone reusing the framework understands which terms apply. When PROTEUS is run together with a GPL-3.0 module, the combination assembled on your machine is subject to the terms of that module's license, and we treat that license as authoritative for any such run. Treating each repository's license as authoritative, and keeping the modules optional and swappable, means the framework can be configured to match the licensing requirements of a project or institution wherever a suitable alternative module is available for each role it needs. -## Permissive licenses are the norm in scientific software +## Permissive licenses are widely used in scientific software -Permissive licensing is the established choice across the scientific software the research community relies on every day. +Permissive licensing is the established choice for the general-purpose scientific software the research community relies on every day. Much of the foundational scientific Python stack, including [NumPy](https://numpy.org), [SciPy](https://scipy.org), [pandas](https://pandas.pydata.org), [scikit-learn](https://scikit-learn.org), and [Astropy](https://www.astropy.org), is released under the permissive BSD 3-Clause license, and [Matplotlib](https://matplotlib.org) under its own, equally permissive license. Major frameworks such as [TensorFlow](https://www.tensorflow.org) and [JAX](https://github.com/jax-ml/jax) use Apache 2.0, the same license as PROTEUS. Many of these tools, including Matplotlib, NumPy, and pandas, grew out of academia and became broadly useful in large part because their permissive licensing posed the fewest obstacles to adoption. -PROTEUS follows the same path. +Domain-specific solver codes are more often released under copyleft licenses, and PROTEUS builds on several of them while respecting their terms. +PROTEUS sits at the framework level, and we license the coupling framework permissively for the same reason: to keep the barrier to building on it as low as possible. ## Credit where it is due From 7187412a3b431bc771c42abc2b4fd31a732a919f Mon Sep 17 00:00:00 2001 From: timlichtenberg Date: Sat, 6 Jun 2026 11:20:51 +0200 Subject: [PATCH 06/14] Restructure the license page and correct several claims The Apache 2.0 section now leads with reach and follows with a condensed patent rationale, scoped to what the license actually grants. The GPL section states the practical cases plainly: running PROTEUS with a GPL module privately imposes no copyleft obligation, redistribution is governed by the GPL. A short section on development in public repositories covers the open development promise in the title. Corrections: pandas did not grow out of academia, so the precedent sentence now names Astropy instead; the modules bullet says that some modules install from FormingWorlds-maintained forks under the upstream license rather than claiming no re-hosting; the credit section distinguishes license notices from scientific credit. Also trims repetition, splits overlong sentences, and evens out the register throughout. --- _pages/license.md | 95 +++++++++++++++++++++++++---------------------- 1 file changed, 51 insertions(+), 44 deletions(-) diff --git a/_pages/license.md b/_pages/license.md index 740f75c..7e11904 100644 --- a/_pages/license.md +++ b/_pages/license.md @@ -6,41 +6,47 @@ permalink: /license/ image: /assets/img/og-default.jpg --- -PROTEUS is built on the conviction that science is strongest when it is open. -Open source code can be read, checked, run, adapted, and improved by anyone, which makes the results that depend on it reproducible and the methods behind them transparent. -We see this not as an optional extra but as a basic requirement for software that sits at the heart of scientific work. -Every part of the framework is therefore released under a recognised open source license. +PROTEUS is fully open source. +Open source code can be read, run, and improved by anyone, which makes the results that depend on it reproducible and the methods behind them transparent. +For scientific software we consider this a requirement, not an optional extra. +Every part of the framework is released under an established open source license. We also believe that open development is the best way to build software that lasts. PROTEUS grows through collaboration: contributions from research scientists, software engineers, students, and many others across institutions and countries. -Keeping the code open, and keeping the barriers to using and contributing to it low, is what allows that community to form and the science to move forward. +Keeping the code open is what allows that community to form and the science to move forward. ## Open source, without exception PROTEUS will only ever support and include fully open source code. We do not build on closed, proprietary, or source-unavailable components, and we do not plan to. If a capability can only be provided by code that is not open, we would rather develop an open alternative than compromise on this principle. -This keeps the entire pipeline, from input data to published figure, inspectable end to end. +This keeps the entire pipeline, from input data to published figure, open to inspection. + +## Developed in the open + +Development of PROTEUS and the modules we maintain happens in public repositories under the [FormingWorlds organisation](https://github.com/FormingWorlds) on GitHub. +Issues, code review, and design discussions are public, and anyone can follow the work, report problems, or propose changes. +Releases are versioned and published, so a published result can state the exact code that produced it. ## A framework of independent modules PROTEUS is a coupling framework rather than a single monolithic program. The physics is divided across a set of modules, each of which handles one domain: the atmosphere, the mantle, outgassing, photochemistry, escape, stellar evolution, tides, or interior structure. -Each module is a complete, standalone program in its own right. -It can be developed, tested, run, and published independently, and it lives in its own repository under its own license. +Each module is a complete, standalone program. +It can be developed, tested, run, and published independently, and it lives in a separate repository under a license chosen by its authors. The PROTEUS coupler orchestrates the exchange of boundary conditions between whichever modules are selected for a given simulation. -Two consequences follow from this design, and both matter for licensing: +One consequence follows from this design, and one is a deliberate choice we have made about distribution. Both matter for licensing: - **Modules are optional and swappable.** No single module is required for the framework to function. You can exchange one atmosphere model for another, enable or disable tidal heating, or substitute a different interior model. -- **Modules are published by their own authors.** PROTEUS does not copy module source code into its own code base, and it does not re-host or relicense any module. The PROTEUS package contains only PROTEUS source code. Where a module is a Python package, PROTEUS names it as a dependency that the package manager retrieves from that module's own published release; other modules are fetched from their own repositories at install time. In each case the code comes from the module's own authors, under the module's own license, and is combined with PROTEUS at run time on the user's machine. +- **Modules are published by their own authors.** PROTEUS does not copy module source code into its code base, and it does not relicense any module. The PROTEUS package contains only PROTEUS source code. Where a module is a Python package, PROTEUS names it as a dependency that the package manager retrieves from the module's published release. Other modules are fetched at install time, in some cases from FormingWorlds-maintained forks of the upstream project, always under the upstream license. In each case the code is combined with PROTEUS at run time on the user's machine. Much of the value of PROTEUS lies in this integration work: bringing established codes together, extending them, and in many cases contributing improvements back to the projects they came from. ## Licenses across the framework Different components carry different licenses, reflecting the choices of their authors. -The authoritative license for any component is always the one stated in its own repository. +The authoritative license for any component is always the one stated in its repository. Representative examples across the ecosystem: @@ -61,57 +67,59 @@ PROTEUS itself, the coupling framework, is released under the [Apache 2.0 licens Apache 2.0 is a permissive license. It lets anyone use, modify, and redistribute the code, including as part of a larger work under a different license, as long as attribution and the license notice are preserved. -Where Apache 2.0 goes further than MIT and BSD is on patents, which those shorter licenses do not cover with an explicit grant. -Apache 2.0 includes an explicit patent grant: each contributor automatically gives every user a perpetual, worldwide, royalty-free license to any of their own patents that are necessarily infringed by the code they contributed, whether on its own or in combination with the rest of the project. -In plain terms, a contributor, or the institution that employs them, cannot have their code accepted into the project and then later assert a patent against the people who use it. -The license also includes a patent retaliation clause: if a user starts patent litigation alleging that the software infringes one of their patents, the patent licenses that user received under Apache 2.0 are terminated. -Together these provisions close a gap that MIT and BSD leave open, where a contributor could grant the copyright permissions while making no express promise about their patents. They also shield the project and its community from patent attacks. -For scientific software this certainty is worth having, because contributors come from many universities, research institutes, and companies, each with their own intellectual property policies and patent portfolios. -The explicit grant lets anyone who builds on PROTEUS use the methods implemented in the code without the risk of a later patent claim from a contributor. -The deeper reason is reach. +Our main reason is reach. A permissive license keeps the barriers to adoption as low as possible. -Researchers and institutions can build on PROTEUS, and integrate parts of it into their own pipelines, without being obliged to release their entire surrounding codebase under a copyleft license. -Some public research institutes, agencies, and companies restrict or prohibit the use of strong-copyleft code precisely because of that obligation. +The alternative, a copyleft license, requires that derived works be released under the same terms. +Researchers and institutions can build on PROTEUS, and integrate parts of it into their pipelines, without taking on that obligation for the surrounding code. +Some public research institutes, agencies, and companies restrict or prohibit the use of strong-copyleft code for precisely this reason. There are situations where strong copyleft is the right choice, for example when the explicit goal is to ensure that every downstream user must in turn keep their derived code open. -For the core PROTEUS framework, whose purpose is to enable science and to be reused as broadly as possible, we judge that making PROTEUS easy to adopt and reuse matters more than forcing that obligation on downstream users. -This is why we prefer Apache 2.0, and more permissive licenses generally, for the framework and for the modules we maintain. +For the core PROTEUS framework, whose purpose is to enable science as broadly as possible, we judge that ease of adoption matters more than that guarantee. + +Among permissive licenses, we choose Apache 2.0 over MIT and BSD because of patents, which those shorter licenses do not cover with an explicit grant. +Under Apache 2.0, each contributor automatically gives every user a perpetual, worldwide, royalty-free license to any of their patents that are necessarily infringed by the code they contributed. +The grant covers that code on its own and in combination with the rest of the project. +The license also includes a patent retaliation clause: if a user starts patent litigation alleging that the software infringes one of their patents, the patent licenses that user received under Apache 2.0 are terminated. +For scientific software this certainty is worth having, because contributors come from many universities, research institutes, and companies, each with different intellectual property policies and patent portfolios. +This is why we license the framework, and the modules we maintain, permissively, with Apache 2.0 as our default. + +## Permissive licenses are widely used in scientific software + +Permissive licensing is the established choice for the general-purpose scientific software the research community relies on every day. +Much of the foundational scientific Python stack, including [NumPy](https://numpy.org), [SciPy](https://scipy.org), [pandas](https://pandas.pydata.org), [scikit-learn](https://scikit-learn.org), and [Astropy](https://www.astropy.org), is released under the permissive BSD 3-Clause license, and [Matplotlib](https://matplotlib.org) under its own, equally permissive license. +Major frameworks such as [TensorFlow](https://www.tensorflow.org) and [JAX](https://github.com/jax-ml/jax) use Apache 2.0, the same license as PROTEUS. +Many of these tools, including Matplotlib, NumPy, and Astropy, grew out of research environments; their permissive licensing removed one obstacle to adoption by companies and institutions alike. +PROTEUS sits at the framework level, and we license the coupling framework permissively for the same reason. +Several of the domain-specific solver codes PROTEUS uses are released under copyleft licenses; the next section describes how the framework respects their terms. ## How Apache 2.0 works alongside GPL-3 modules Some modules used by PROTEUS are released under the GPL-3.0 license. -Apache 2.0 and GPL-3.0 are compatible in one direction: Apache 2.0 code may be incorporated into a GPL-3.0 project, in which case the combined result is governed by the GPL, but GPL-3.0 code may not be incorporated into an Apache 2.0 project. -PROTEUS does not incorporate GPL-3.0 source code into its own code base, so this one-directional constraint does not arise for PROTEUS itself. +Apache 2.0 and GPL-3.0 are compatible in one direction: Apache 2.0 code may be incorporated into a GPL-3.0 project, and the combined result is then governed by the GPL. +The reverse does not hold: GPL-3.0 code may not be incorporated into an Apache 2.0 project. +PROTEUS does not incorporate GPL-3.0 source code into its code base, so this constraint does not arise for PROTEUS itself. The framework relies instead on the modular, separately distributed design described above. The GPL's strong copyleft obligations attach to the distribution of a combined work. -Because the PROTEUS package contains only its own Apache 2.0 code, and each module is published separately by its own authors under its own license, it is our understanding that the PROTEUS package itself does not distribute a combined work that includes GPL-3.0 code. -The modules remain independent programs, each governed by its own license. - -When PROTEUS is run together with a GPL-3.0 module, the combination assembled on your machine is subject to the terms of that module's license, and we treat that license as authoritative for any such run. -Treating each repository's license as authoritative, and keeping the modules optional and swappable, means the framework can be configured to match the licensing requirements of a project or institution wherever a suitable alternative module is available for each role it needs. - -## Permissive licenses are widely used in scientific software +The PROTEUS package contains only Apache 2.0 code, and each module is published separately by its authors. +It is our understanding that the PROTEUS package therefore does not distribute a combined work that includes GPL-3.0 code, and that the modules remain independent programs, each governed by its own license. -Permissive licensing is the established choice for the general-purpose scientific software the research community relies on every day. -Much of the foundational scientific Python stack, including [NumPy](https://numpy.org), [SciPy](https://scipy.org), [pandas](https://pandas.pydata.org), [scikit-learn](https://scikit-learn.org), and [Astropy](https://www.astropy.org), is released under the permissive BSD 3-Clause license, and [Matplotlib](https://matplotlib.org) under its own, equally permissive license. -Major frameworks such as [TensorFlow](https://www.tensorflow.org) and [JAX](https://github.com/jax-ml/jax) use Apache 2.0, the same license as PROTEUS. -Many of these tools, including Matplotlib, NumPy, and pandas, grew out of academia and became broadly useful in large part because their permissive licensing posed the fewest obstacles to adoption. -Domain-specific solver codes are more often released under copyleft licenses, and PROTEUS builds on several of them while respecting their terms. -PROTEUS sits at the framework level, and we license the coupling framework permissively for the same reason: to keep the barrier to building on it as low as possible. +In practice: running PROTEUS together with a GPL-3.0 module on your own machine imposes no copyleft obligation on your code, because nothing is distributed. +If you redistribute the combination, or modify and redistribute a module, that distribution is governed by the GPL. +On this understanding, and because the modules are optional and swappable, a simulation can be configured to meet the licensing requirements of a project or institution, provided a suitable alternative module exists for each role. ## Credit where it is due -A permissive license sets out how code may be used; it says nothing about the credit owed to the people who wrote it. -We treat scientific credit as a separate and serious obligation, fully independent of licensing. -PROTEUS exists because of the work of the wider community, and many of its modules build directly on codes developed and published by others. +A permissive license requires little beyond preserving copyright and license notices; it says nothing about the scientific credit owed to the people who wrote the code. +We treat that credit as a separate and serious obligation, fully independent of licensing. +PROTEUS exists because of the work of the wider community, and many of its modules extend codes developed and published by others. We are committed to giving that work proper credit: - The documentation and code link to the relevant publications and repositories for every module, so the original work is easy to find and cite. - Modules that wrap or extend an existing code point to the original project and its papers. -- Users of PROTEUS are asked to cite the manuscripts listed in the [bibliography](https://proteus-framework.org/PROTEUS/Reference/bibliography), to state the code version used, and to include an acknowledgement. +- We ask users of PROTEUS to cite the manuscripts listed in the [bibliography](https://proteus-framework.org/PROTEUS/Reference/bibliography), to state the code version used, and to include an acknowledgement. Our full guidance on citation, authorship, and acknowledgement is set out in the [contributing guidelines](https://proteus-framework.org/PROTEUS/Community/CONTRIBUTING). @@ -119,10 +127,9 @@ Our full guidance on citation, authorship, and acknowledgement is set out in the Licensing in open source is nuanced, and reasonable people read parts of it differently. We have set out our position here, and we welcome questions, corrections, and discussion. -If you maintain a code we build on, are considering building on PROTEUS, or simply want to understand our approach better, please get in touch. +If you maintain a code we depend on, are considering using PROTEUS in your own work, or simply want to understand our approach better, please get in touch. You can reach us through [GitHub Discussions](https://github.com/orgs/FormingWorlds/discussions), open an issue on the relevant repository, or email [proteus_dev@formingworlds.space](mailto:proteus_dev@formingworlds.space). -We are always happy to talk this through.