There are two models for managing code – with different mechanisms for contributions – managed and legacy. The managed model is recommended, and the legacy model will likely be phased out over time.

1. Managed model (recommended)
The new OpenNTF Alliance makes code as re-usable as possible by leveraging the ALv2. OpenNTF strongly recommends to post all future code under ALv2. The new catalog only contains code under ALv2 or compatible licenses in order to allow consumers to find reusable code on OpenNTF as easily as possible. In order to be able to use ALv2 for code on OpenNTF, due diligence needs to be done. Contributors have to follow an inbound contribution process.
The Alliance members recognize that not all contributions can be made under ALv2. For example, contributions that are based on Eclipse components (licensed under the EPL), may be required to retain the EPL. The Alliance will maintain an IP approval mechanism to handle these exceptions.

2. Legacy model
In the past, OpenNTF contributors could choose whatever license they want or even no license at all. This led to a plethora of different licenses being used, and the absence of licenses resulted in legal ambiguity as to the rights downloaders might have to use the code.
Owners of existing projects and snippets from the code bin are now encouraged to re-contribute their code under ALv2, but until this is done the existing code will continue to be hosted under the current license terms.

OpenNTF differentiates between two different types of contributors:
1. Committers are special contributors who may commit code.
2. Contributors who are not committers can for example write fixes for defects and share this code with committers who can then decide to commit the code.

Contribution Process

In order to be able to use the managed model, due diligence needs to be done. Contributors have to follow an inbound contribution process (see here). They need to ensure the Alliance that they have clear rights to make the contribution. This means that either the code must have been written in its entirety by the contributor or that the contributor must have a clear license to include any third party code in the contribution. An example of including third party code in a contribution would be the contribution of a modified version of the per-existing ALv2-licensed OpenNTF component. The IP (intellectual property) ownership is retained by the author of the code.

In particular in order to contribute code under ALv2 contributors need to provide this information:
  • All contributors need to be registered (see here)
  • If the contributor's employer is an OpenNTF member:
  • If the contributor's employer is not an OpenNTF member:

Applying Apache License

All contributions under the managed model need to use the Apache License v2. This license needs to be applied in the code - see here.

Types of Code Contributions

On OpenNTF there are three different types of code (see catalog chapter above):

1. Projects
Projects are the most sophisticated type of code on OpenNTF. In contrast to other types of code there is a full project management infrastructure. See here for a sample of a project: XPages Wiki

Projects have initial releases and typically later updates. Projects have committers who are the project owners (also known as chefs) and can optionally have contributors (also known as cooks). Users can submit defects, write testimonials, submit requirements, have discussions with the contributors, etc.

Project owners can only choose a license other than ALv2 where ALv2 is not appropriate for some reason such as where a project includes code licensed under a different open source license such as the EPL.

OpenNTF users can create new projects when they are logged in on this page.

2. Reusable controls
OpenNTF users can post simpler snippets of code in the OpenNTF code bin. New entries can be created on this page.

All future entries to the catalog will be done under the ALv2. It is recommended that contributors also follow the contribution process (managed model) since only then these entries can show up in the catalog.

3. Rich client components
Rich client components are stored in an Eclipse update site database on OpenNTF and are all listed in the catalog (see here for sample).

Only contributors who followed the contribution process (managed model) can add rich client components that can be installed via drag & drop into the Notes client.

In order to contribute a rich client component send a mail with the following information to (see here for more details):
  • Descriptions: One liner plus one page plus 1 or 2 screenshots
  • Code as zip (with applied ALv2) with the sources as Eclipse projects and the update site
  • Meta information like 'Committed by', 'All contributors', 'Tested platforms'

Non Code Contributions

OpenNTF users can contribute code but they can also get engaged without contributing code (see here), e.g. by posting ideas in IdeaJam.

More details

Details about contributions can be found here:
Non Code Contributions
Applying Apache License
Contribution Process
Employers Consent
Members Agreement and IPPolicy
Terms of Use