keepcalculator

06 Numbers and Powers

Open Source Governance Changes: What Happens

Card No. 06·80520 · Updated · Standard formula, shown below

When an open source project changes its governance, the rules and decision-making power shift, which can alter everything from who contributes code to who controls the project’s trademark and direction. The immediate effects are usually felt in contributor workflows, release schedules, and community trust, while long-term consequences can include forks, funding changes, or even a complete rewrite of the project’s license. This article explains what governance changes look like in practice, why they happen, and what they mean for maintainers, contributors, and users.

Background: Why Governance Matters

Open source governance is the set of policies, processes, and people that decide how a project is run. It covers who can merge code, how decisions are made, how conflicts are resolved, and who owns the project’s assets (like the domain name, GitHub org, and trademark). For most small projects, governance is informal—the founder just does everything. But as a project grows, governance becomes explicit, often written down in a GOVERNANCE.md file or a formal charter.

Changes to governance are common. A project might move from a single maintainer to a team, adopt a foundation, or switch from a benevolent dictator model to a consensus-based community. Each type of change has different triggers and consequences. For example, a project may change governance because the original maintainer steps down, because a company wants to fund it, or because the community demands more transparency. Understanding the background helps you predict what will happen after a change.

Types of Governance Models

There is no single open source governance model, but most projects fall into a few broad categories. Knowing these helps you understand what a change actually involves.

  • Benevolent Dictator for Life (BDFL) – A single leader (or small group) has final say on all decisions. Python and Linux are famous examples. Changes here are rare and often involve succession planning.
  • Meritocracy / Do-ocracy – Those who contribute the most get more decision-making power. Changes here often involve adding or removing committers.
  • Community / Consensus – Decisions are made by a group of elected or appointed maintainers, often with voting. Changes here involve altering the voting process or the composition of the governing board.
  • Foundation / Corporate – A non-profit foundation (like the Apache Foundation or Linux Foundation) holds the assets and provides legal protection. Changes here are major, often involving transferring copyright and trademark.

Most governance changes move a project from a less formal to a more formal model, but sometimes projects go the other way (e.g., a company spins out a project as community-led).

How a Governance Change Happens

There is no standard procedure, but most changes follow a similar arc. The process usually starts with a proposal, often triggered by a crisis or a major milestone.

  1. Proposal – Someone (usually a maintainer or a company) writes a document describing the new governance structure. This is often posted publicly on the project’s mailing list or GitHub.
  2. Discussion – The community reviews the proposal. This can take weeks or months, with revisions based on feedback.
  3. Vote or Approval – Depending on the current rules, the proposal may be voted on by existing maintainers, or the founder may just announce the change.
  4. Implementation – The new rules are codified in the project’s documentation, and any structural changes (like forming a foundation) are executed.
  5. Transition – The project starts operating under the new rules. This often includes onboarding new maintainers or transferring ownership of assets.

For example, when a project moves to a foundation, the change involves legal steps: transferring copyright to the foundation, setting up a board of directors, and adopting a trademark policy. This is a slow, formal process that can take a year or more.

Immediate Effects on Contributors and Users

The most visible changes happen in day-to-day operations. Contributors may see new guidelines for submitting pull requests, different code review processes, or new requirements for signing off on commits. Users may notice a change in release cadence or a new code of conduct.

One common immediate effect is a change in who has commit access. If governance shifts from a BDFL to a team, new people get the ability to merge code, which can speed up development but also lead to inconsistent decisions. Conversely, if a project becomes more restrictive (e.g., a company takes over), some contributors may lose commit rights, leading to resentment.

Another immediate effect is on the project’s roadmap. New governance often brings new priorities, especially if a company or foundation is involved. Features that were once deprioritized might get funded, while others are dropped. This can be jarring for users who relied on certain features.

Common Problems and Misconceptions

One common misconception is that a governance change automatically means the project will be sold or become closed source. In reality, most governance changes are designed to keep the project open, but they can still go wrong. Here are the most frequent problems:

  • Community split – If the change is seen as illegitimate, a group of developers may fork the project. A famous example is the OpenOffice to LibreOffice fork, which happened after governance concerns.
  • Loss of momentum – The time spent on governance discussions is time not spent on code. Projects can stall for months during a transition.
  • Power concentration – A change that looks democratic on paper can actually centralize power in a few people, especially if voting rules are opaque.
  • Legal issues – If the change involves transferring copyright or trademarks, mistakes can lead to lawsuits or loss of the project’s name.
  • Burnout – Governance changes are stressful for maintainers, and some may step down, leaving the project with fewer active leaders.

Another misconception is that governance changes are always voluntary. Sometimes a company that employs the main maintainer forces a change, or a hostile takeover happens via a license change. These are rare but can be devastating.

How to Evaluate a Governance Change

If you’re a contributor or user of a project that’s changing governance, you should ask a few key questions before deciding whether to stay or leave.

  • Is the change transparent? Are the discussions public? Are the new rules written down and accessible?
  • Who benefits? Does the change give more power to the community, or to a company? Is there a conflict of interest?
  • What happens to the license? Will the project remain under an open source license? Can the new governance change the license later?
  • How are disputes resolved? Is there a clear process for handling disagreements? Who has the final say?
  • What is the track record? Have the people involved run other projects? Have they honored past promises?

If the change is being made to address a real problem (like a single point of failure), it’s often a good sign. If it’s being made in secret or with a rushed timeline, that’s a red flag.

Alternatives to Changing Governance

Governance changes are not the only way to solve a project’s problems. Sometimes a less drastic approach works better.

  • Adding maintainers – Instead of changing the whole structure, just add more people with commit access. This is the simplest fix for a bus factor issue.
  • Adopting a code of conduct – If the problem is social, a code of conduct with an enforcement team can improve the community without changing decision-making.
  • Creating a working group – For a specific issue (like security), create a sub-group with limited authority rather than overhauling the whole governance.
  • Forking – If the current governance is truly broken, forking the project is a more extreme alternative that lets you start fresh.

Choosing the right alternative depends on the root cause. If the issue is a lack of contributors, adding maintainers is best. If it’s a lack of trust, a more formal governance model might be needed.

Frequently Asked Questions

Q: Can a governance change make a project closed source?
Yes, but it’s rare. A governance change could include a license change, but most projects are careful to keep the code open. However, a company that controls the governance could theoretically change the license in the future, so it’s important to read the new rules carefully.

Q: What happens to my contributions if governance changes?
Your existing contributions remain under the project’s license, and you keep your copyright. However, the new governance may require you to sign a Contributor License Agreement (CLA) for future contributions, which gives the project (or its new owner) more rights to your code.

Q: How long does a governance change take?
It varies widely. A simple change like adding a co-maintainer can happen in a week. Moving to a foundation can take over a year because of legal processes. The discussion phase alone often takes months.

Q: Should I stop using a project if its governance changes?
Not necessarily. Evaluate the change based on transparency, the people involved, and the project’s license. If the change is positive (e.g., more community involvement), it might be a reason to stay. If it’s a corporate takeover with unclear motives, you might want to look for alternatives.

Q: Can a governance change be reversed?
Yes, but it’s difficult. If the change was made by a founder, the founder can revert it. If it was made by a board or foundation, reversing requires a new decision by that body. In practice, most governance changes are permanent, and reversing them often leads to a fork.

Q: What is the difference between governance and license?
Governance is about who makes decisions and how. License is about what you can do with the code. A project can change governance without changing its license, and vice versa. However, a governance change can lead to a license change if the new leadership decides to relicense the code.

Related

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.

More cards in this drawer

The whole Numbers and Powers drawer →