<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Eclipse Governance Articles on Eclipse Project Governance Articles</title><link>https://www.eclipse.org/projects/articles/governance/</link><description>Recent content in Eclipse Governance Articles on Eclipse Project Governance Articles</description><generator>Hugo</generator><language>en</language><managingEditor>webdev@eclipse-foundation.org (Eclipse Foundation)</managingEditor><webMaster>webdev@eclipse-foundation.org (Eclipse Foundation)</webMaster><lastBuildDate>Tue, 31 Mar 2026 00:00:00 +0000</lastBuildDate><atom:link href="https://www.eclipse.org/projects/articles/governance/index.xml" rel="self" type="application/rss+xml"/><item><title>Eclipse Open Source Projects and OpenChain (ISO/IEC 5230)</title><link>https://www.eclipse.org/projects/articles/governance/openchain-5230/</link><pubDate>Tue, 31 Mar 2026 00:00:00 +0000</pubDate><author>webdev@eclipse-foundation.org (Eclipse Foundation)</author><guid>https://www.eclipse.org/projects/articles/governance/openchain-5230/</guid><description>&lt;p>The global landscape of open source development is increasingly defined by the need for transparency, trust, and a rigorous approach to supply chain security. As organisations integrate thousands of third-party components into their proprietary stacks, the burden of ensuring that every piece of software is legally &lt;em>clean&lt;/em> and properly licensed has grown considerably. In this context, the Eclipse Foundation has long distinguished itself through a governance model that prioritises intellectual property (IP) due diligence. The emergence of formal standards like ISO/IEC 5230—better known as the OpenChain specification—provides an internationally recognised benchmark for licence compliance.&lt;/p>
&lt;p>By aligning the Eclipse Foundation’s established processes with the OpenChain standard, Eclipse open source projects can provide downstream adopters and consumers with a high degree of confidence. While many projects at the Eclipse Foundation naturally follow these rigorous paths, specific criteria must be met before a project can formally claim to be OpenChain compliant. This alignment is not merely a bureaucratic exercise; it is a fundamental part of the Foundation’s mission to foster a commercially friendly ecosystem.&lt;/p>
&lt;h1 id="the-life-cycle-of-an-eclipse-project">The Life cycle of an Eclipse Project&lt;/h1>
&lt;p>To understand how compliance is achieved, one must first understand the life cycle of an Eclipse open source project as defined by the Eclipse Foundation Development Process (along with the practical guidance provided by the &lt;a href="https://www.eclipse.org/projects/handbook">Eclipse Project Handbook&lt;/a>). Every Eclipse open source project begins its journey in the &lt;a href="https://www.eclipse.org/projects/handbook/#incubation">incubation phase&lt;/a>. This is an onboarding period where the project team learns the &amp;ldquo;rules of the road&amp;rdquo;, adopting the &lt;a href="https://www.eclipse.org/projects/handbook/#preamble-principles">core principles&lt;/a> of openness, transparency, and meritocracy. During incubation, the primary focus is on establishing a functioning community and integrating with the Eclipse Foundation’s governance, practices and processes (including the &lt;a href="https://www.eclipse.org/projects/handbook/#ip">IP due diligence process&lt;/a>).&lt;/p>
&lt;p>Graduation is a significant milestone. A project in the mature phase has demonstrated to the community that they are working in a vendor-neutral manner and are faithfully engaging in the IP due diligence process. Graduation is a formal recognition of process adoption. For the purposes of OpenChain compliance, being in the mature phase is a prerequisite. It signals to the community that the project is no longer &amp;ldquo;learning the ropes&amp;rdquo; but is instead operating at a level of professional governance expected by adopters.&lt;/p>
&lt;p>An Eclipse open source project moves from the incubation phase into the mature phase by engaging in a &lt;a href="https://www.eclipse.org/projects/handbook/#release-graduation">graduation review&lt;/a>; graduation reviews are combined with a &lt;a href="https://www.eclipse.org/projects/handbook/#progress-review">progress review&lt;/a>. Following a successful graduation review and graduation into the mature phase, an Eclipse open source project will engage in periodic progress reviews.&lt;/p>
&lt;h2 id="the-role-of-progress-reviews-and-ip-due-diligence">The Role of Progress Reviews and IP Due Diligence&lt;/h2>
&lt;p>Conducted by the &lt;a href="https://www.eclipse.org/projects/handbook/#roles-emo">Eclipse Management Organization&lt;/a> (EMO) and the Eclipse open source project’s &lt;a href="https://www.eclipse.org/projects/handbook/#roles-pmc">Project Management Committee&lt;/a> (PMC), a progress review is an annual check-in to ensure the project continues to align with the Eclipse Foundation&amp;rsquo;s practices and processes. For a project to claim OpenChain compliance, it must have successfully completed a progress review while already in the mature phase.&lt;/p>
&lt;p>A critical component of a progress review is the validation of the open source projects&amp;rsquo; continued faithful implementation of the Eclipse Foundation IP due diligence process. The IP due diligence process requires that all content—whether it be original code or third-party libraries—be scrutinised for legal cleanliness. &lt;a href="https://www.eclipse.org/projects/handbook/#roles-cm">Committers&lt;/a> are responsible for ensuring that every contributor has a valid &lt;a href="https://www.eclipse.org/projects/handbook/#contributing-eca">contributor agreement&lt;/a> on file and that the provenance of all code is documented. During a progress review, the EMO validates that these practices are being implemented correctly.&lt;/p>
&lt;p>While an Eclipse open source project must produce a &lt;a href="https://www.eclipse.org/projects/handbook/#ip-sbom">Software Bill of Materials&lt;/a> (SBOM) in a standard format to claim OpenChain compliance, the Foundation does not currently require the creation of an SBOM as a condition for passing a standard progress review. The review focuses on the integrity of the IP process itself, whereas the SBOM is the outward-facing documentation of that integrity.&lt;/p>
&lt;h2 id="implementing-the-openchain-requirements">Implementing the OpenChain Requirements&lt;/h2>
&lt;p>The OpenChain specification (ISO/IEC 5230) is structured around several key goals, ranging from establishing a programme foundation to managing the delivery of compliance artifacts. Through its governance model, the Eclipse Foundation addresses these requirements as a service to its projects. The following breakdown highlights how the Foundation’s practices, processes, and policies, as detailed (in part) in the Eclipse Project Handbook, map to the high-level requirements of the OpenChain standard.&lt;/p>
&lt;h2 id="programme-foundation-and-awareness">Programme Foundation and Awareness&lt;/h2>
&lt;p>The first pillar of OpenChain compliance is the establishment of a documented policy. The Eclipse Foundation fulfills this through our &lt;a href="https://eclipse.org/org/documents/Eclipse_IP_Policy.pdf">Intellectual Property Policy&lt;/a> and the corresponding sections of the Eclipse Project Handbook. These documents provide the legal and procedural baseline for all activity within the ecosystem. Awareness is fostered through the &lt;a href="https://www.eclipse.org/legal/committer-guidelines/">Committer Due Diligence Guidelines&lt;/a>, to which all elected committers must agree. These guidelines explicitly detail the expectations regarding code provenance and the use of third-party software.&lt;/p>
&lt;p>The Eclipse Foundation provides multiple &lt;a href="https://www.eclipse.org/projects/training/">training modules&lt;/a>, including specific education on &lt;a href="https://www.eclipse.org/projects/training/#ip">IP due diligence&lt;/a>, for Eclipse committers.&lt;/p>
&lt;h2 id="roles-responsibilities-and-staffing">Roles, Responsibilities, and Staffing&lt;/h2>
&lt;p>OpenChain requires that an organisation identify the roles responsible for the compliance programme and ensure they are appropriately staffed. At the Eclipse Foundation, these roles are clearly delineated between the committers, the PMCs, and the professional staff of the EMO. Specifically, the responsibility for receiving and responding to external compliance inquiries is held by the Eclipse Foundation&amp;rsquo;s &lt;a href="https://www.eclipse.org/projects/handbook/#ip-team">IP Team&lt;/a>.&lt;/p>
&lt;p>The IP Team handles inquiries from the committer community and does all of the hard work involved in IP due diligence. This centralised function ensures consistency across hundreds of projects. The Eclipse IP Team is staffed by professionals with backgrounds in IP risk management and data analysis ensuring that the &lt;em>competency&lt;/em> requirement of ISO/IEC 5230 is met with a high degree of rigour.&lt;/p>
&lt;h2 id="review-and-remediation-processes">Review and Remediation Processes&lt;/h2>
&lt;p>A core requirement of any compliance programme is a process for identifying and reviewing the obligations of open source licences. The Eclipse Foundation addresses this through a combination of automated scanning and manual review.&lt;/p>
&lt;p>Every third-party library or contribution that is not original code from a committer is vetted via the IP due diligence process. The IP Team uses a variety of scanning tools to identify the licences involved and check for compatibility with the project’s own licence. When a non-compliant case or a &lt;em>problematic&lt;/em> licence is identified, the Foundation has documented procedures for remediation. This might involve working with the project team to replace a dependency or identify a different version. This systematic approach ensures that by the time an Eclipse open source project reaches its release, the &lt;em>licence obligations&lt;/em> mentioned in OpenChain have been thoroughly vetted.&lt;/p>
&lt;h2 id="compliance-artifacts-and-delivery">Compliance Artifacts and Delivery&lt;/h2>
&lt;p>OpenChain focuses on the delivery of compliance artifacts. This includes ensuring that the software distribution is accompanied by the necessary licence texts and notices. The Eclipse Project Handbook mandates that all projects include standard legal files and proper copyright headers.&lt;/p>
&lt;p>The introduction of the SBOM requirement for OpenChain-compliant projects is the final piece of this puzzle. By requiring a standard-format SBOM, the Eclipse Foundation ensures that downstream adopters and consumers receive a comprehensive inventory of the software. This inventory allows adopters to perform their own risk assessments and ensures that the transparency promised by the Eclipse process is accessible in an automated, industry-standard way.&lt;/p>
&lt;h1 id="the-value-of-standardised-compliance">The Value of Standardised Compliance&lt;/h1>
&lt;p>The alignment of Eclipse projects with ISO/IEC 5230 is more than a branding exercise; it is a response to the needs of the global software industry. As regulations like the Cyber Resilience Act in Europe and various executive orders in the United States place more pressure on software producers to vouch for their supply chains, having a &lt;em>known-good&lt;/em> process is essential.&lt;/p>
&lt;p>The Eclipse Foundation’s model is particularly powerful because it relieves individual project teams of much of the administrative burden. By providing the policy framework, the legal expertise, the scanning infrastructure, and the liaison functions, the Foundation allows developers to focus on innovation while remaining within the guardrails of legal safety. When a project lead at the Eclipse Foundation asserts that their project is OpenChain compliant, they are not just making a promise; they are pointing to a verified history of graduation, successful mature-phase progress reviews, and a machine-readable SBOM.&lt;/p>
&lt;h1 id="conclusion">Conclusion&lt;/h1>
&lt;p>In the world of open source, trust is the ultimate currency. For decades, the Eclipse Foundation has built that trust through a meticulous, hands-on approach to intellectual property. By embracing the OpenChain specification, the Foundation has provided its projects with a way to translate that internal rigour into a globally recognised standard of excellence.&lt;/p>
&lt;p>The path to compliance is clear: a project must graduate into maturity, maintain its standards through regular progress reviews, and provide the community with an SBOM. This journey, guided by the Eclipse Project Handbook and supported by a dedicated team of experts, ensures that Eclipse projects remain at the forefront of the professional open source movement. As organisations look for certainty in their software supply chains, the combination of Eclipse governance and OpenChain compliance provides a robust, scalable, and dependable solution for the future of digital innovation.&lt;/p>
&lt;hr>
&lt;p>Please also see:&lt;/p>
&lt;ul>
&lt;li>&lt;a href="https://www.eclipse.org/projects/articles/governance/successful-open-source-project/">Running a Successful Open Source Project&lt;/a>&lt;/li>
&lt;li>&lt;a href="https://www.eclipse.org/projects/articles/governance/incubation/">Incubation in the Eclipse Foundation Development Process&lt;/a>&lt;/li>
&lt;/ul>
&lt;hr>
&lt;p>We&amp;rsquo;ve created &lt;a href="https://gitlab.eclipse.org/eclipsefdn/it/websites/eclipse.org-projects-articles/-/issues/9">this issue&lt;/a> as place to post comments and discuss this article. If you have questions about Eclipse Project Governance, contact &lt;a href="mailto:emo@eclipse-foundation.org">emo@eclipse-foundation.org&lt;/a>.&lt;/p></description></item><item><title>Incubation in the Eclipse Foundation Development Process</title><link>https://www.eclipse.org/projects/articles/governance/incubation/</link><pubDate>Fri, 13 Feb 2026 00:00:00 +0000</pubDate><author>webdev@eclipse-foundation.org (Eclipse Foundation)</author><guid>https://www.eclipse.org/projects/articles/governance/incubation/</guid><description>&lt;p>By Wayne Beaton&lt;/p>
&lt;p>Becoming an Eclipse open source project is a process, not an event: it may take your new open source project weeks or months to various adopt the principles, processes, and practices that the community have come to expect Eclipse open source project teams to follow and implement.&lt;/p>
&lt;p>All new Eclipse open source projects start in the incubation phase; it is during the incubation phase that teams learn to be an Eclipse open source project. Incubation is designed to ensure projects:&lt;/p>
&lt;ul>
&lt;li>Adopt core Eclipse principles (openness, transparency, meritocracy);&lt;/li>
&lt;li>Successfully integrate with Eclipse legal and IP processes; and&lt;/li>
&lt;li>Establish sustainable community and security practices.&lt;/li>
&lt;/ul>
&lt;p>Let’s back up a bit. The &lt;a href="https://www.eclipse.org/projects/dev_process/">Eclipse Foundation Development Process&lt;/a> describes the phases of the Eclipse open source project life cycle.&lt;/p>
&lt;p>&lt;strong>Pre-proposal Phase.&lt;/strong> The pre-proposal phase is basically a non-existence phase. During the pre-proposal phase, you will assemble a project proposal that contains information about the project’s goals, identifies the initial list of committers (maintainers) and project leads, identifies issues or concerns, and otherwise informs the community about the project. During the pre-proposal phase, the proposal is kept private to you and your team. During the pre-proposal phase, the EMO will help you prepare the proposal, and – when everyone is ready – move the project into the proposal phase by publishing the proposal document and announcing it to the community.&lt;/p>
&lt;p>&lt;strong>Proposal Phase.&lt;/strong> During the &lt;a href="https://www.eclipse.org/projects/dev_process/#6_2_2_Proposal">proposal phase&lt;/a>, the EMO works with your project team and community to provide feedback and gather all of the information that we need to create the project. When the project team is ready, we create the new open source project, engage with your committers to make sure that we have agreements in place, provision resources, and work with the project team to transfer their existing code and practices over to the Eclipse Foundation. At this point, your open source project enters the incubation phase.&lt;/p>
&lt;p>&lt;strong>Incubation Phase.&lt;/strong> The &lt;a href="https://www.eclipse.org/projects/dev_process/#6_2_3_Incubation">incubation phase&lt;/a> serves as an onboarding period where your project team learns and adopts the principles and practices of the Eclipse Foundation Development Process. Note that the incubation phase is concerned with project teams adopting open source practices that are consistent with the Eclipse Foundation Development Process; the concept of incubation is unrelated to code quality or stability: a project that has stable code base starts in incubation when it is moved to the Eclipse Foundation. After establishing itself as a functioning Eclipse open source project, the project graduates into the mature phase.&lt;/p>
&lt;p>&lt;strong>Mature Phase.&lt;/strong> Your Eclipse open source project will spend most of its lifetime in the &lt;a href="https://www.eclipse.org/projects/dev_process/#6_2_4_Mature">mature phase&lt;/a>, after your project team “learns the ropes” in incubation.&lt;/p>
&lt;p>&lt;strong>Archived Phase.&lt;/strong> During the archived phase, the project is, well… archived. When an Eclipse open source project has reached the end of its life cycle or is no longer sustainable, it may be terminated and archived.&lt;/p>
&lt;p>Having established the project&amp;rsquo;s formal status, the following practices are the core responsibilities that every project team must diligently implement during the incubation phase to ensure a successful path to the mature phase.&lt;/p>
&lt;h1 id="incubation-practices">Incubation Practices&lt;/h1>
&lt;p>Always remember that onboarding the project as an Eclipse open source project is a process not an event. Everyone knows that your project team won’t get everything right on day one. Steady progress is the name of the game.&lt;/p>
&lt;p>While the project is in the incubation phase, your project team will engage in the following practices.&lt;/p>
&lt;h2 id="collaboration-and-governance">Collaboration and Governance&lt;/h2>
&lt;p>&lt;strong>Operate transparently.&lt;/strong> Operating transparently is an early step in adopting open collaboration practices. Move your issue tracking into the public issue trackers provided for the project by the Eclipse Foundation. Use your issue tracker to create issues for features that you are implementing anyway.&lt;/p>
&lt;p>&lt;strong>Operate openly.&lt;/strong> Develop a habit of using public issues to discuss features, bugs, and other project level discussions. Learn to frame discussions in a manner that invites others to participate.&lt;/p>
&lt;p>&lt;strong>Operate meritocratically.&lt;/strong> Provide an environment in which others can contribute and develop a reputation. This is tightly coupled with operating transparently and openly. Make growing your communities a priority: set up the project to encourage contributions (pull/merge requests) and be prepared to interact with contributors and accept (merge) contributions. Help contributors develop reputation and elect them as committers. Ensure that meritocracy is based on the contributions of an individual, not the goals or hiring practices of any specific organisation.&lt;/p>
&lt;p>&lt;strong>Operate in a vendor-neutral manner.&lt;/strong> Vendor neutrality is the natural consequence of operating transparently, openly, and meritocratically. A sure sign that a project is operating in a vendor-neutral manner is having committers and contributors who represent the interests of more than one organisation.&lt;/p>
&lt;p>&lt;strong>Give up absolute control.&lt;/strong> When you move the project to the Eclipse Foundation, it ceases to be yours alone. Sharing control with the other developers who “show up” is an important part of growing a community around the project.&lt;/p>
&lt;h2 id="technical-and-infrastructure">Technical and Infrastructure&lt;/h2>
&lt;p>&lt;strong>Use infrastructure provided by the Eclipse Foundation.&lt;/strong> Switching from internal development to working in the open can be challenging. It will be tempting for project teams who are not already familiar with open collaboration to continue development using internal resources and periodically pushing content out to the Eclipse project repository.&lt;/p>
&lt;p>During the incubation phase, project teams must learn to collaborate in the open; developers must get used to pushing their commits directly to the project’s source code repositories and contributors – even those that work for the same company as project committers – need to get used to interacting with the project via pull requests; and everybody needs to learn to communicate both short and long term plans through public issues and other public resources.&lt;/p>
&lt;p>Making it so that people who are outside of the core development team have the ability to access the most up-to-date version of the project code is an absolute requirement. To that end, your committers must push content directly into designated open repositories. Eclipse project committers must never stage to a private or semi-private repository and then periodically sync to the open repository; employing this sort of strategy raises a significant barrier for entry that makes it impossible for anybody else to participate.&lt;/p>
&lt;p>&lt;strong>Provide project metadata and legal documentation.&lt;/strong> All members of the various communities that grow around the project expect to find a README file in the repository root with information about the project. The community will also expect to find a CONTRIBUTING file that describes how to contribute to the project (e.g., what branches are active, how to build, that an ECA is required by contributors, etc.). It’s also become standard to expect that Git repositories have a LICENSE file in the root that contains the full text of the project license.&lt;/p>
&lt;p>The absolute low bar with regard to &lt;a href="https://www.eclipse.org/projects/handbook/#incubation-communities">community development&lt;/a> is to provide basic &lt;a href="https://www.eclipse.org/projects/handbook/#legaldoc">legal documentation&lt;/a> for the project.&lt;/p>
&lt;p>When technically feasible, include a &lt;a href="https://www.eclipse.org/projects/handbook/#ip-copyright-headers">copyright and licence header&lt;/a> in all source files.&lt;/p>
&lt;p>Release software. Projects in the incubation phase can issue major, minor, and service releases. Engage in at least one release while the project is in the incubation phase. Traditionally, a project in the incubation phase numbers their releases &amp;lt; 1.0 (e.g. “0.7”), but there is no requirement to do so.&lt;/p>
&lt;h2 id="compliance-and-risk-management">Compliance and Risk Management&lt;/h2>
&lt;p>&lt;strong>Engage in the &lt;a href="https://www.eclipse.org/projects/handbook/#ip">Eclipse Intellectual Property (IP) Due Diligence Process&lt;/a>.&lt;/strong> We set new Eclipse open source projects up for some early success: the IP Team will automatically engage in a due diligence review of the project’s initial contribution shortly after you move it in the project’s source code repositories, and will engage with the project leads if their investigation uncovers issues that require discussion. The EMO also ensures that committers and contributors are covered by agreements that ensure that the project is able to receive contributions under terms that are consistent with the project’s licence and the open source model.&lt;/p>
&lt;p>During the incubation phase, the project&amp;rsquo;s committers will learn to initiate IP and vulnerability reviews for &lt;a href="https://www.eclipse.org/projects/handbook/#ip-third-party">third party&lt;/a> components (e.g., libraries that the project&amp;rsquo;s adopters require to use the code).&lt;/p>
&lt;p>The IP due diligence process provides flexibility for projects while they are in the incubation phase; the implication being that there may be some modest increase in intellectual property-related risk (especially when combined with a new development team who don’t yet live and breathe the &lt;a href="https://www.eclipse.org/org/documents/Eclipse_IP_Policy.pdf">Eclipse IP Policy&lt;/a>).&lt;/p>
&lt;p>&lt;strong>Establish security and vulnerability management practices.&lt;/strong> During the incubation phase, the project team will adopt processes for identifying, reporting, and responding to vulnerability reports and other security concerns (e.g., build chain security). Your team will build a relationship with the Eclipse Foundation’s Security Team and gain familiarity with how we manage vulnerabilities and work with the Security Team to publish official Common Vulnerabilities and Exposures (CVE) reports.&lt;/p>
&lt;p>&lt;strong>Engage in a successful progress review.&lt;/strong> As the name suggests, a progress review is the means by which the EMO and PMC check in on projects to see how they are progressing. Especially when a project is in the incubation phase, we’re looking for progress in adapting your practices to align with principles, processes, and practices that are consistent with open collaboration at the Eclipse Foundation.&lt;/p>
&lt;h2 id="graduation">Graduation&lt;/h2>
&lt;p>&lt;strong>Graduate into the mature phase.&lt;/strong> The project can’t stay in the incubation phase forever: plan your graduation into the mature phase. The project is probably ready for graduation when your project team has demonstrated that they’re working in an open, transparent, and meritocratic manner; are otherwise engaged in activities that foster vendor neutrality; are faithfully engaging in the IP due diligence process and healthy security/vulnerability management; have engaged in a progress review; and are distributing software.&lt;/p>
&lt;p>Key graduation requirements and their primary goal:&lt;/p>
&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>Incubation Practice&lt;/th>
 &lt;th>Core Objective&lt;/th>
 &lt;th>Key Indicator of Success&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>Operate Transparently&lt;/td>
 &lt;td>Foster public oversight and collaboration&lt;/td>
 &lt;td>All development discussions and issue tracking are public&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Use Eclipse Infrastructure&lt;/td>
 &lt;td>Eliminate private development &amp;ldquo;staging&amp;rdquo;&lt;/td>
 &lt;td>Direct commits to Eclipse repositories; no periodic syncing&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Engage in IP Due Diligence&lt;/td>
 &lt;td>Ensure legal cleanliness and contribution safety&lt;/td>
 &lt;td>Successful initial contribution review; timely third-party reviews initiated by committers&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Release Software&lt;/td>
 &lt;td>Demonstrate technical and process maturity&lt;/td>
 &lt;td>Successful completion of at least one public release (e.g., v0.x)&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Graduate to Mature Phase&lt;/td>
 &lt;td>Formal recognition of full process adoption&lt;/td>
 &lt;td>Demonstrates open, meritocratic operation, passed progress review&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table>
&lt;p>Graduation is a significant event and worthy of celebration. We&amp;rsquo;ll celebrate with you.&lt;/p>
&lt;h1 id="incubation-branding">Incubation Branding&lt;/h1>
&lt;p>That a project is in the incubation phase serves, in part, as a flag for adopters and the community at large that the project team is still learning the ropes; it serves as a flag to adopters that the project team may not be correctly implementing the Eclipse Foundation’s intellectual property due diligence process, or may not be yet be operating in a fully vendor-neutral manner per the Open Source Rules of Engagement. This ensures adopters are aware that while the project is active, the IP review process (for third-party components, for example) is still being internalised by the new team.&lt;/p>
&lt;p>Incubation is an invitation to potential adopters to take a closer look and take a little extra care before incorporating the project’s content into their products.&lt;/p>
&lt;p>Incubation branding is one way that we ensure that adopters understand the project’s incubation state. Primarily, this takes the form of displaying the incubation logo in prominent locations, including the project’s major web properties and including the word &amp;ldquo;incubation&amp;rdquo; or warning that products shipped as part of a release may include incubating components.&lt;/p>


&lt;figure class="eclipsefdn-figure col-xs-24">
 &lt;img class="img img-responsive margin-x-auto" src="https://www.eclipse.org/projects/articles/governance/images/incubating.png"
 alt="Incubation Logo"/> &lt;figcaption class="text-center">
 &lt;p>The Incubation Logo&lt;/p>
 &lt;/figcaption>
&lt;/figure>

&lt;p>Incubating branding includes:&lt;/p>
&lt;ul>
&lt;li>Display the incubation logo on the project web page;&lt;/li>
&lt;li>Display the incubation logo on the project’s primary download page;&lt;/li>
&lt;li>Include the word &amp;ldquo;incubation&amp;rdquo; in the filename of all downloadable files (when technically feasible) for builds; and&lt;/li>
&lt;li>When technically feasible, include the word &amp;ldquo;incubation&amp;rdquo; in features (e.g. about dialogs, feature lists, and installers).&lt;/li>
&lt;/ul>
&lt;p>There are no incubation branding requirements for any user-facing elements.&lt;/p>
&lt;h1 id="conclusion">Conclusion&lt;/h1>
&lt;p>The incubation phase is a critical onboarding period for new projects at the Eclipse Foundation, designed to ensure project teams successfully adopt the fundamental principles of open, transparent, and meritocratic collaboration, alongside essential practices like vendor neutrality, use of Eclipse infrastructure, compliance with IP due diligence, and establishment of security protocols. It is a time for learning and demonstrating commitment to the Eclipse Foundation Development Process, with progress reviews and the requirement to release software serving as milestones. The incubation phase signals this transitional status to the broader community and adopters, underscoring that while the project is active, it is still maturing in its adherence to all governance standards before achieving the full confidence and stability associated with graduation into the mature phase.&lt;/p>
&lt;hr>
&lt;p>Please also see &lt;a href="https://www.eclipse.org/projects/articles/governance/successful-open-source-project/">Running a Successful Open Source Project&lt;/a>&lt;/p>
&lt;hr>
&lt;p>We&amp;rsquo;ve created &lt;a href="https://gitlab.eclipse.org/eclipsefdn/it/websites/eclipse.org-projects-articles/-/issues/7">this issue&lt;/a> as place to post comments and discuss this article. If you have questions about Eclipse Project Governance, contact &lt;a href="mailto:emo@eclipse-foundation.org">emo@eclipse-foundation.org&lt;/a>.&lt;/p></description></item><item><title>Running a Successful Open Source Project</title><link>https://www.eclipse.org/projects/articles/governance/successful-open-source-project/</link><pubDate>Fri, 14 Nov 2025 00:00:00 +0000</pubDate><author>webdev@eclipse-foundation.org (Eclipse Foundation)</author><guid>https://www.eclipse.org/projects/articles/governance/successful-open-source-project/</guid><description>&lt;p>By Wayne Beaton and Gunnar Wagenknecht&lt;/p>
&lt;p>Running an open source project is easy. All you have to do is make your source code available and you’re open source, right? Well, maybe. Ultimately, whether or not an open source project is successful depends on your definition of success. Regardless of your definition, creating an open source project can be a lot of work. If you have goals regarding adoption, for example, then you need to be prepared to invest. While open source software is “free as in beer”, it’s not really free: time and energy are valuable resources and these valuable resources need to be invested in the project.&lt;/p>
&lt;p>So, how do you invest those resources?&lt;/p>
&lt;p>&lt;strong>Define success&lt;/strong>. Before you can consider running a successful open source project, you need to have a clear definition of success. There are many factors to consider. Is it enough to just get some code into a publicly accessible repository or do you want more for your project? Is collaboration and adoption important to you? Are you just trying to build your reputation as as software developer? Does your definition of success long include long term viability? Do you want to grow a community around the project? Do you care about commercial adoption? Your answer to these questions can help you decide how many of the rest of our recommendations you’ll need to adopt.&lt;/p>
&lt;p>&lt;strong>Be transparent&lt;/strong>. Transparency is pretty simple to understand: make it so that the community can watch and understand what you’re doing: use a publicly accessible source code repository that’s easy to find, use public facing issue tracking software, post your release plans where the community can find them, and capture meeting minutes in public forums (e.g. mailing lists with archives).&lt;/p>
&lt;p>&lt;strong>Be open&lt;/strong>. For a lot of open source projects, “transparency” and “openness” mean the same thing, but the terms really are quite different. Being open is more than just being “open book” (which is essentially the same thing as transparency). For many, the “open” in open source means open to new ideas, or open to participation. The rules for participating in an open source project should be the same for everybody (“level playing field”): it’s not enough to just accept a few patches, you have to be open to new ideas. In short, you have to let others in and give up absolute control of the project.&lt;/p>
&lt;p>&lt;strong>Keep the “Playing Field Level”&lt;/strong>. This doesn&amp;rsquo;t necessarily mean that you have to let just anybody join the project, but rather that you ensure that the same set of rules apply to everybody (the playing field may be level, but you still have to earn your way onto the field). Meritocracy is about earning your way in. Some projects implement meritocracy, for example, by requiring that developers make some number of contributions to demonstrate that they understand the code, rules, and culture of the project before inviting them to join the project team. Make sure that the process for adding new developers to your project are well known and that the process is operated transparently (e.g. a public vote).&lt;/p>
&lt;p>&lt;strong>Be vendor neutral&lt;/strong>. In order to be truly open, people need to feel welcome to contribute. This is easier if the project is vendor neutral. A vendor neutral project is not dominated by any organisation or organisations; meritocracy should be based on the contributions of an individual, not the goals or hiring practices of any specific organisation. Hosting at vendor neutral foundation is one way to achieve this.&lt;/p>
&lt;p>&lt;strong>Have well defined and documented standards&lt;/strong>. Be sure to document your project’s code formatting rules (make code formatter preferences easily accessible), expectations with regard to test coverage, development methodology, software and tools required, channels to connect with the project team, and other important information for potential contributors. Capture all of this information and make it as easy as possible to find. It’s a good practice to include a contribution guide in the root of your projects source code repositories (with DVCS, it’s entirely possible that potential contributors will find a copy of a copy of a copy of your repository; having the contribution guide in the repository will make it easy for potential contributors to find their way home).&lt;/p>
&lt;p>&lt;strong>Ensure that the project code is always buildable&lt;/strong>. Include build scripts and instructions with the project code. Make it as easy as possible to successfully build and test the project code.&lt;/p>
&lt;p>&lt;strong>Connect with your user community&lt;/strong>. The user community is that group of people who use the products of your open source project. The user community rarely contributes anything directly to the project code, but does tend to ask a lot of questions. Make sure that those questions get answered. A healthy user community feeds an adopter community.&lt;/p>
&lt;p>&lt;strong>Connect with your adopter community&lt;/strong>. An obvious sign of success for an open source project is that other groups start to use your open source project in their own products, or build extensions. This community is more willing to give back to the project and will be the project’s best source of contributions. Some number of those contributors will be great candidates to join your project’s team. Development of an eco-system of adopters and extenders is a great way to ensure the longevity of your project.&lt;/p>
&lt;p>&lt;strong>Connect with your development community&lt;/strong>. The development community is comprised of your project’s team members and contributors. Provide well-known channels for communication within this community. Having clear lines of communication will help developers collaborate.&lt;/p>
&lt;p>&lt;strong>Have a plan&lt;/strong>. It’s easy to lapse into a pattern of just letting software development happen, but like any process (especially a software development process), having some method to the madness is critical. Make sure that your project employs a development methodology and make sure that somebody owns the process (e..g a project lead). Having a plan helps developers know where they can contribute the most value and makes it easier for adopters and extenders to implement their own plans (and thereby be successful). Treat your open source project like any other software development project.&lt;/p>
&lt;p>&lt;strong>Manage your brand&lt;/strong>. Your project will have a brand. The project’s name is its identity; as is the project logo, along with the names of any products (it’s typical that an the products of an open source project share the name of the project, but some projects produce more than one product). Claim the project’s brand as a trademark and consider registering that trademark. Establish trademark usage guidelines so that adopters know how to use your brand. This is an area where working with an open source software foundation can add value. A foundation can hold and defend the project’s trademarks on behalf of the community. This avoids letting any particular individual or organisation hold the project’s name hostage (this happens).&lt;/p>
&lt;p>&lt;strong>Pick an OSI-approved open source licence&lt;/strong>. Don’t create your own custom licence; that will just add legal hurdles for anybody who wants to use your code. Make sure that the licence that you choose is compatible with the manner in which you intend for the code to be used. Further, ensure that the licence is compatible with any third party content (e.g. libraries) that your project code needs. Include the SPDX code for your licence in the headers for all source files.&lt;/p>
&lt;p>&lt;strong>Manage Intellectual property and copyright&lt;/strong>. The code, documentation, and other artifacts contributed to the project is intellectual property. Who owns that intellectual property? Do the authors retain their ownership, or do they assign it to another entity? Make sure that the rights and responsibilities of contributors are understood by all contributors. Consider having contributors sign a developer certificate of origin (DCO) or a contributor licence agreement (CLA). Ensure that copyright notices are included with the source code and in notices.&lt;/p>
&lt;p>Note that it is unlikely that the project itself is a legal entity that can hold copyrights. This is another way in which an open source foundation can provide a valuable service.&lt;/p>
&lt;p>&lt;strong>Care about security and mitigating vulnerabilities&lt;/strong>. Make sure that your builds are as secure as possible and that the software repositories that your builds pull content from are stable and secure. Enable private vulnerability reporting and create private channels that are to be used only for discussion of undisclosed vulnerabilities (be sure to summarise and/or move information into public channels after vulnerabilities have been remediated and disclosed). Have a policy regarding disclosure. What do you do, for example, when a vulnerability is taking too long to resolve? Do you report unpatched vulnerabilities to your community or do you keep it to yourself until after a patch is available? There are different schools of thought on this topic.&lt;/p>
&lt;p>&lt;strong>Move your project to an open source foundation&lt;/strong>. We&amp;rsquo;ve mentioned foundations a few times already. A foundation can first and foremost help you to keep your project vendor neutral, which will help adoption: a bit part of the appeal of open source software is that adopters can avoid being beholden to a particular organisation. A foundation can hold onto and defend the project’s trademarks, establish a governance model, help you manage your brand, provide intellectual property management services, and just generally provide assistance and advice for operating a successful open source project. Being a part of an open source foundation provides a value feedback loop. The foundation provides credibility for your open source project which in turn provides credibility to the foundation.&lt;/p>
&lt;p>Running an open source project is a lot of work. But, as we&amp;rsquo;ve suggested, how much work it takes really depends on your definition of success. Fall back on the core principles of open source development: transparency, openness, and meritocracy. Everything else comes from that.&lt;/p>
&lt;hr>
&lt;p>We presented this content as a talk at the OCX Webinar Week in November 2025:&lt;/p>




&lt;a 
 class="eclipsefdn-video" 
 href="//www.youtube.com/embed/ltbYK4JhgRY"
 
>&lt;/a>

&lt;hr>
&lt;p>We&amp;rsquo;ve created &lt;a href="https://gitlab.eclipse.org/eclipsefdn/it/websites/eclipse.org-projects-articles/-/issues/6">this issue&lt;/a> as place to post comments and discuss this article. If you have questions about Eclipse Project Governance, contact &lt;a href="mailto:emo@eclipse-foundation.org">emo@eclipse-foundation.org&lt;/a>.&lt;/p></description></item><item><title>Organising Your Eclipse Open Source Project Team</title><link>https://www.eclipse.org/projects/articles/governance/organising-your-team/</link><pubDate>Tue, 07 Oct 2025 00:00:00 +0000</pubDate><author>webdev@eclipse-foundation.org (Eclipse Foundation)</author><guid>https://www.eclipse.org/projects/articles/governance/organising-your-team/</guid><description>&lt;p>By Wayne Beaton&lt;/p>
&lt;p>The &lt;a href="https://www.eclipse.org/projects/dev_process/">Eclipse Foundation Development Process&lt;/a> (EDP) clearly defines the roles of contributors, committers, and project leads. It deliberately refrains, however, from dictating internal team organisation, thereby granting project teams significant autonomy in establishing their own leadership structures and decision-making processes. As always, these practices, like all of an Eclipse open source project’s practices, must align with the Open Source Rules of Engagement defined in the EDP, should be clearly documented, and applied consistently.&lt;/p>
&lt;h2 id="standard-roles">Standard Roles&lt;/h2>
&lt;p>The EDP defines a &lt;em>&lt;a href="https://www.eclipse.org/projects/handbook/#contributing-contributors">contributor&lt;/a>&lt;/em> role: contributors are individuals who have made valuable contributions to the project but do not yet have the decision-making authority of a committer. They typically submit their work via pull requests or patches, which are then reviewed and merged by existing committers. The contributor role serves as an important entry point for new community members to demonstrate their skills and commitment to the project, often as a stepping stone towards becoming a committer.&lt;/p>
&lt;p>The EDP defines a &lt;em>&lt;a href="https://www.eclipse.org/projects/handbook/#roles-cm">committer&lt;/a>&lt;/em> role: committers are those developers who have the ability to make decisions for the project (e.g., push commits to project Git repositories and configure build servers). We often say that the committers are the ones with the real power: they’re the ones that hold all of the keys to all of the project resources. Committers must have a good understanding of the project governance, and have a responsibility to apply open source best practices and maintain a level playing field. With great power comes great responsibility, so we have a well-defined process by which a contributor may demonstrate to the existing project committers that they are worthy of joining them as a peer.&lt;/p>
&lt;p>The EDP defines a &lt;em>&lt;a href="https://www.eclipse.org/projects/handbook/#roles-pl">project lead&lt;/a>&lt;/em> role: project leads are responsible for ensuring that the processes are being followed. So, for example, project leads need to ensure that committers are engaging in the IP due diligence process and are implementing the Eclipse Foundation Security Policy. But they are also responsible for ensuring that committers are “playing nice”. That is, they have responsibility to ensure that the entire project team is engaged in practices that are consistent with being open, transparent, and meritocratic as described in the Open Source Rules of Engagement. To wit, project leads are responsible for ensuring that the project is maintaining a level playing field that is open to all comers and that the project is operating in a vendor-neutral manner. The EDP does not explicitly grant project leads any special power or authority to make technical decisions on behalf of the project team.&lt;/p>
&lt;p>Other than defining contributors, committers, and project leads, the EDP says nothing about how teams organise. We expect that project teams sort this out for themselves.&lt;/p>
&lt;h2 id="other-roles">Other Roles&lt;/h2>
&lt;p>While it is natural to have one or more committers become technical leaders in the project team, there is no formal &lt;em>technical lead&lt;/em> role defined in the EDP. Likewise, while it is natural for certain members of a specification project team to become leaders in the specification process, there is no formal notion of &lt;em>specification lead&lt;/em> defined in the &lt;a href="https://www.eclipse.org/projects/efsp">Eclipse Foundation Specification Process&lt;/a> (EFSP). Any de facto technical or specification lead does not have any special authority beyond that which is granted to them by the other project committers.&lt;/p>
&lt;p>Other project roles may emerge. The committers may decide, for example, that they will not merge contributions unless they are approved by a UX expert.&lt;/p>
&lt;p>The committers in a project team have considerable influence over who their leaders are and what powers they grant to those leaders. While the role is not specifically defined for this sort of thing, the project lead role could be granted decision making powers. It is completely reasonable for a project team to decide, for example, that somebody in the project lead role must approve of all contributions and anybody with that role can mitigate potential rogue actions by rolling back commits. One of the key benefits of organising in this manner is that project lead is an elected position, so project committers have a built-in process for capturing the decision to grant those extra powers.&lt;/p>
&lt;p>Any special authority that is granted to an individual only persists for as long as the committers support the individual. It is natural for individuals to cease to be recognised as technical leaders after some period of inactivity, or when committers disagree with their decisions.&lt;/p>
&lt;h2 id="how-does-this-work">How Does This Work?&lt;/h2>
&lt;p>For many open source projects, the committers follow the natural leaders, and that’s the end of it. But when a more formal relationship is desired, it must be arrived at by consensus of the project team (via public channels) and documented clearly so that everybody can understand how the project team works (making it very clear how a project team works is a critically important aspect of growing diversity in your project team). If the project team decides, for example, that all committers must contribute their updates as pull requests that may only be merged by a project lead, then that must be documented (it’s fairly common for project teams to require that pull requests from one committer be merged by a different committer).&lt;/p>
&lt;p>When an open source project or organisation formally defines a role, they must clearly document how someone actually earns that elevated status. This documentation should lay out the specific requirements and steps involved in becoming a committer, keeping things transparent and fair. The criteria should be based around earned authority: publicly demonstrated competence through contribution.&lt;/p>
&lt;p>It&amp;rsquo;s absolutely essential that these criteria for ascending into a custom role have nothing to do with someone&amp;rsquo;s employment status. To keep things vendor-neutral and encourage a truly open and welcoming environment, the qualifications for a role must only be based on their proven contributions, technical know-how, community involvement, and alignment with project values. Linking status to employment gives an unfair advantage to employees of a particular vendor and will inevitably erode the collaborative, independent spirit of an open source project.&lt;/p>
&lt;h2 id="examples">Examples&lt;/h2>
&lt;p>Here are some examples of custom roles, and the criteria by which an individual might earn those roles.&lt;/p>
&lt;p>A project team might decide to define a notion of &lt;em>code owner&lt;/em>, that grants specific individuals or groups responsibility for particular modules or components of the codebase. Code owners would be tasked with reviewing and approving all pull requests affecting their designated code, ensuring quality, consistency, and adherence to project standards. They would also serve as the primary point of contact for issues or questions related to their owned code. The criteria for becoming a code owner could include a deep understanding of the specific codebase area, a history of significant contributions to that area, and demonstrated expertise in its design and implementation.&lt;/p>
&lt;p>A project team might decide to define a &lt;em>release manager&lt;/em> role, responsible for coordinating release cycles, ensuring all necessary testing is completed, managing version numbers, and overseeing the final deployment of new software versions. The release manager would not have any special technical authority beyond what is granted by the committers, but their decisions regarding release readiness and timing would be respected and followed by the project team. The criteria for becoming a release manager could be based on demonstrated organisational skills, attention to detail, a thorough understanding of the project&amp;rsquo;s development and deployment processes, and a history of reliable contributions to previous release efforts.&lt;/p>
&lt;p>A project team might define a &lt;em>user experience (UX) lead&lt;/em> role, responsible for guiding the overall user experience strategy of the project. The UX lead would focus on understanding user needs, conducting usability testing, creating user flows and wireframes, and ensuring that the project&amp;rsquo;s design aligns with best practices and user expectations. This role would involve collaboration with committers to integrate UX considerations into technical implementations. Criteria for becoming a UX lead could include a demonstrated history of contributing UX advice and designs to the project, expertise in relevant UX areas, an understanding of the project&amp;rsquo;s user experience architecture and design principles, and a proven ability to collaborate effectively within the project community.&lt;/p>
&lt;p>The pattern should be clear from these examples: formal roles require some public demonstration of skills and competence. These examples also demonstrate progressive responsibility: individuals take on greater responsibility and leadership roles as they demonstrate their capability and commitment to the project over time.&lt;/p>
&lt;h2 id="conclusion">Conclusion&lt;/h2>
&lt;p>While the Eclipse Foundation Development Process defines core roles like contributor, committer, and project lead, it deliberately empowers project teams to establish their own internal leadership structures and decision-making processes. This autonomy, however, comes with the responsibility of ensuring all practices align with the Open Source Rules of Engagement, are clearly documented, and applied consistently. Whether through formal consensus or the natural emergence of technical and specification leaders, the committers ultimately hold the authority to define and grant special powers within their teams, always prioritising open contribution and a vendor-neutral environment to foster a truly open and collaborative open source project.&lt;/p>
&lt;hr>
&lt;p>We&amp;rsquo;ve created &lt;a href="https://gitlab.eclipse.org/eclipsefdn/it/websites/eclipse.org-projects-articles/-/issues/3">this issue&lt;/a> as place to post comments and discuss this article. If you have questions about Eclipse Project Governance, contact &lt;a href="mailto:emo@eclipse-foundation.org">emo@eclipse-foundation.org&lt;/a>.&lt;/p></description></item><item><title>Committer Status for a New Hire</title><link>https://www.eclipse.org/projects/articles/governance/committer-status-new-hire/</link><pubDate>Tue, 02 Sep 2025 00:00:00 +0000</pubDate><author>webdev@eclipse-foundation.org (Eclipse Foundation)</author><guid>https://www.eclipse.org/projects/articles/governance/committer-status-new-hire/</guid><description>&lt;p>By Wayne Beaton&lt;/p>
&lt;p>Every once in a while, we get a request to make somebody a committer on one of our open source projects. These often come from companies that are already contributing to the project, and have either hired a new developer or reassigned an existing developer to work specifically on the project. At face value, this sounds like a good thing: open source projects are starving for resources, and adding a whole new committer can have a massive impact on the ability of the project team to deliver. Our answer to this sort of request, however, is “no” (that’s not the full answer: we try very hard to be much more polite than that).&lt;/p>
&lt;p>Operating in a vendor-neutral manner is a goal for all Eclipse open source projects, and requires a clear separation between decisions made by participating companies and collaborative development in open source projects.&lt;/p>
&lt;h2 id="open-source-rules-of-engagement">Open Source Rules of Engagement&lt;/h2>
&lt;p>This isn&amp;rsquo;t a matter of gatekeeping or an indication of a lack of trust. Rather, it’s a direct consequence of the foundational principles that govern the health and sustainability of open source projects. The &lt;em>Open Source Rules of Engagement&lt;/em> defined in the &lt;a href="https://www.eclipse.org/projects/dev_process/">Eclipse Foundation Development Process&lt;/a> describes fundamental principles—openness, transparency, and meritocracy—that form the foundation of everything that we do. The Open Source Rules of Engagement ensure that projects remain fair, vibrant, and vendor-neutral.&lt;/p>
&lt;p>Let’s discuss these in reverse order.&lt;/p>
&lt;h3 id="meritocracy">Meritocracy&lt;/h3>
&lt;p>An individual&amp;rsquo;s standing and influence within the community are earned through the quality and quantity of their contributions, not by their job title, employer, or reputation from a different sphere. Committer status, the ultimate recognition of a project member&amp;rsquo;s trust and responsibility, is not a gift or reward.&lt;/p>
&lt;p>What does this &amp;ldquo;merit&amp;rdquo; actually look like? It’s far more than just writing code. A developer can demonstrate their value to the community in a multitude of ways:&lt;/p>
&lt;ul>
&lt;li>&lt;strong>High-Quality Code Contributions:&lt;/strong> Submitting well-written, thoroughly tested patches or pull requests that solve real problems or add valuable features. This is the most direct form of merit.&lt;/li>
&lt;li>&lt;strong>Constructive Code Reviews:&lt;/strong> Providing insightful feedback on others&amp;rsquo; contributions, helping to improve the overall quality of the project.&lt;/li>
&lt;li>&lt;strong>Issue Triage and Support:&lt;/strong> Actively participating in discussions on issues, offering advice, and guiding new users through common problems.&lt;/li>
&lt;li>&lt;strong>Documentation and Tutorials:&lt;/strong> Improving the project&amp;rsquo;s documentation, writing clear examples, or creating tutorials that make the project more accessible to newcomers.&lt;/li>
&lt;li>&lt;strong>Community Leadership:&lt;/strong> Engaging in project discussions, participating in design debates, and helping to steer the project&amp;rsquo;s direction.&lt;/li>
&lt;/ul>
&lt;p>The key is that these contributions must be visible to everyone. The community must be able to see the work and collectively agree that this person is a valuable and trusted member who deserves greater responsibility. Committer status isn&amp;rsquo;t about being a good programmer; it&amp;rsquo;s about being a good community member. A new developer, no matter how talented, has not yet had the opportunity to demonstrate this on a public stage. They need time to build their reputation and earn the trust of the existing committers.&lt;/p>
&lt;h3 id="transparency">Transparency&lt;/h3>
&lt;p>The process for becoming a committer must be open for all to see. This means there can be no &amp;ldquo;backroom deals&amp;rdquo; or special exceptions made behind closed doors. The entire journey of a candidate, from their first contribution to their nomination, must be a matter of public record.&lt;/p>
&lt;p>This is where the importance of tools like Git and public forums comes into play. Every pull request, every issue comment, every mailing list discussion—these all contribute to a public, transparent record of an individual&amp;rsquo;s engagement and merit. The commit record provides a clear, immutable history of who has contributed what to the project.&lt;/p>
&lt;p>Transparency holds the community accountable. When a new committer is proposed, everyone can review their contributions and voice their support or concerns. This peer review process is a powerful check against favouritism or cronyism. Transparency builds trust. A community that operates in the open is one that developers, both corporate-sponsored and independent, feel safe participating in. They know that the rules are the same for everyone and that their efforts will be recognised on their own merits.&lt;/p>
&lt;h3 id="openness">Openness&lt;/h3>
&lt;p>The final, and perhaps most subtle, principle is openness. This means that the path to committer status is open to anyone, regardless of who they are or who they work for. The playing surface must be level, and the rules must apply equally to all participants.
This is the core reason why a company&amp;rsquo;s hiring decision cannot directly translate to committer status. If an employer could simply appoint a committer, it would inject corporate bias into a meritocratic system. The project would risk becoming a tool for a single company&amp;rsquo;s agenda, rather than a community-driven effort.
The open source model thrives on diversity of thought and contribution. It benefits from input from individuals at different companies, from independent developers, and from academics. By ensuring that committer status is based purely on a person&amp;rsquo;s demonstrated contributions to the project, the community safeguards itself from the undue influence of any one entity.&lt;/p>
&lt;h2 id="earning-committer-status">Earning Committer Status&lt;/h2>
&lt;p>So, what is the right way for a new hire to become a committer? The answer is to follow the same path that every other committer has taken: demonstrate their value publicly.&lt;/p>
&lt;p>This isn&amp;rsquo;t a silly or unnecessary hoop to jump through. It’s a practical, essential part of professional development within the open source world. If a developer is truly ready for the responsibilities of a committer, they should be able to produce a few high-quality contributions, participate in discussions, and generally engage with the community in a way that is visible and valuable. This process might take a few weeks or a few months, but it’s an invaluable period of acclimation. It’s during this time that they learn the project&amp;rsquo;s code base, its community norms, and its technical direction. They get to know the people, and the people get to know them.&lt;/p>
&lt;p>Committer status is not a symbolic title. It comes with real, practical responsibilities and powers: the ability to merge code, to approve releases, and to make binding decisions on the project&amp;rsquo;s future. It is a position of trust, and that trust must be earned and demonstrated. The moment a new hire demonstrates that they have the trust of the existing community, they can be nominated, and the committers can vote on their promotion with confidence. This process is what ensures the project’s long-term health and independence.&lt;/p>
&lt;p>The open source world is built on a foundation of trust and shared responsibility. That trust is not a given; trust is earned through open, transparent, and meritocratic engagement. The goal should not be to shortcut this process but to support their new team member in navigating it successfully. The right way to grant committer status for a new hire is to empower them to become one by their own merits, demonstrating to the community that they are a truly valuable asset—not just to their employer, but to the project itself.&lt;/p>
&lt;hr>
&lt;p>Please also see &lt;a href="https://www.eclipse.org/projects/articles/posts/contributing-a-git-repository/">Contributing a Git Repository&lt;/a>&lt;/p>
&lt;hr>
&lt;p>We&amp;rsquo;ve created &lt;a href="https://gitlab.eclipse.org/eclipsefdn/it/websites/eclipse.org-projects-articles/-/issues/4">this issue&lt;/a> as place to post comments and discuss this article. If you have questions about Eclipse Project Governance, contact &lt;a href="mailto:emo@eclipse-foundation.org">emo@eclipse-foundation.org&lt;/a>.&lt;/p></description></item></channel></rss>