Is Plane Open Source? License, Source Code, and Self-Hosting Guide

Yes, Plane is 100% open source under the GNU Affero General Public License v3.0 (AGPL-3.0), a strong copyleft license that requires source code distribution for any network-served modifications.

Plane is an open-source project management tool developed by Makeplane. If you are wondering "Is Plane open source," the answer is definitively yes—the entire codebase for this Jira and Linear alternative is publicly available in the makeplane/plane repository and released under the AGPL-3.0 license.

Understanding Plane's Open Source License (AGPL-3.0)

Plane is released under the GNU Affero General Public License v3.0 (AGPL-3.0). This license is a strong copyleft variant of the GPL that specifically addresses network use. According to the LICENSE.txt file in the repository root, any modified versions of Plane that you deploy over a network must also provide the source code to the users interacting with that service.

The README.md explicitly confirms the open-source nature and links directly to the license file. This transparency ensures that self-hosted instances remain aligned with the project's open-source philosophy.

How to Access the Plane Source Code

You can clone the public repository to inspect the license and source code locally. The preview branch contains the latest development version.

# Clone the public repository (preview branch)

git clone -b preview https://github.com/makeplane/plane.git
cd plane

# Verify the license file is present

cat LICENSE.txt | head -n 5

Running the verification command outputs the standard AGPL header:

GNU AFFERO GENERAL PUBLIC LICENSE
   Version 3, 19 November 2007

Copyright (C) 2007 Free Software Foundation, Inc.

You can also programmatically verify the license using Python:

import pathlib

license_path = pathlib.Path("LICENSE.txt")
print(license_path.read_text(encoding="utf-8").splitlines()[:3])

# ['GNU AFFERO GENERAL PUBLIC LICENSE', '   Version 3, 19 November 2007', '']

Exploring the Open Source Codebase Structure

The makeplane/plane repository is organized as a monorepo with distinct applications for the frontend and backend. The package.json at the root level defines this as an npm workspace, coordinating the various JavaScript packages.

Frontend: React and TypeScript (apps/web/)

The main web interface resides in apps/web/. This directory contains the React-based frontend that users interact with when self-hosting Plane. The codebase uses TypeScript for type safety and Next.js for server-side rendering capabilities.

Backend: Django API (apps/api/)

The backend logic is located in apps/api/, implementing a Django-based REST API. This Python codebase handles project management logic, database operations, and authentication. The full-stack nature of the open-source project allows complete inspection of how data flows from the UI to the database.

Reusable UI Components (@plane/ui)

Plane ships with its own internal UI package that can be imported by other applications in the monorepo. You can import components directly from this package:

// Example: import a Plane UI component (the repo ships a React UI package)
import { Button } from "@plane/ui";

export const Demo = () => <Button variant="primary">Plane Demo</Button>;

AGPL-3.0 Compliance for Self-Hosting

When you self-host Plane, the AGPL-3.0 license imposes specific obligations. Unlike permissive licenses such as MIT or Apache 2.0, the AGPL requires that if you modify the code and make it available over a network (even as a private internal tool), you must provide the source code of those modifications to the users accessing the service.

This requirement ensures that improvements to the project management tool remain available to the community. The license text in LICENSE.txt contains the full legal terms governing distribution, modification, and patent grants.

Summary

• Is Plane open source? Yes, Plane is fully open source under the AGPL-3.0 license.
• Where is the license? The complete license text is in LICENSE.txt at the repository root.
• What type of license? AGPL-3.0 is a strong copyleft license requiring source code sharing for network-deployed modifications.
• Can I self-host? Yes, the repository includes everything needed to self-host, including the web frontend (apps/web/) and Django backend (apps/api/).

Frequently Asked Questions

Is Plane free to use commercially?

Yes, Plane is free to use commercially under the AGPL-3.0 license. You can self-host the project management tool for internal company use without paying license fees. However, if you modify the source code and provide access to the modified version over a network, you must share those modifications under the same license terms.

Do I need to share my modifications if I self-host Plane?

If you self-host Plane for internal use only, you do not need to distribute your modifications to the public. However, if you provide access to a modified version of Plane over a network to external users or clients, the AGPL-3.0 requires you to provide the source code of those modifications to those users. This is the key distinction between AGPL and more permissive open-source licenses.

How does Plane's license compare to MIT or Apache 2.0?

Plane's AGPL-3.0 is a strong copyleft license, whereas MIT and Apache 2.0 are permissive licenses. The AGPL requires that any distributed or network-deployed modified versions must be released under the same license with source code available. MIT and Apache 2.0 allow proprietary modifications and do not require source code disclosure, making them more permissive for commercial closed-source derivatives.

Where can I find the official license text?

The official license text is located in the LICENSE.txt file in the root of the makeplane/plane repository. You can view it directly on GitHub or by cloning the repository and opening the file locally. The README.md also contains a link to this license file for quick reference.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}