What Programming Language is makeplane/plane Written In?

MakePlane Plane is built primarily with Python (Django) for the backend API and TypeScript (React) for the frontend client.

Plane is an open-source project management platform developed as a full-stack application. Understanding the programming languages used in the makeplane/plane repository is essential for contributors and developers looking to customize or deploy the platform. The codebase follows a modern architecture where Python handles server-side logic while TypeScript delivers type-safe browser interactions.

Backend: Python and Django

The server-side logic resides in a Python ecosystem built on the Django framework. In apps/api/plane/wsgi.py, you will find the standard WSGI entry point that bootstraps the Django application for production deployment.

API Views and Business Logic

The backend exposes REST endpoints through class-based views. For example, apps/api/plane/web/views.py contains handlers like HealthCheckView that demonstrate Django view patterns:

# apps/api/plane/web/views.py

from django.http import JsonResponse
from django.views import View

class HealthCheckView(View):
    def get(self, request):
        return JsonResponse({"status": "ok"})

Source: apps/api/plane/web/views.py

Database Models

Data persistence is handled via Django ORM models defined in Python. The apps/api/plane/db/models/workspace.py file defines core entities like workspaces, illustrating the relational model that underpins the platform's multi-tenant architecture.

Frontend: TypeScript and React

The client application is a modern React application written in TypeScript and bundled with Vite. Configuration files like apps/web/vite.config.ts reveal the build toolchain that compiles the type-safe code.

State Management with MobX

Frontend state management relies on MobX stores. The apps/web/core/store/user/profile.store.ts file implements a ProfileStore class using makeAutoObservable to manage user data reactively:

// apps/web/core/store/user/profile.store.ts
import { makeAutoObservable } from "mobx";

export class ProfileStore {
  name = "";
  email = "";

  constructor() {
    makeAutoObservable(this);
  }

  setProfile(data: { name: string; email: string }) {
    this.name = data.name;
    this.email = data.email;
  }
}

Source: apps/web/core/store/user/profile.store.ts

Routing and Configuration

Client-side routing logic is configured in apps/web/app/routes/redirects/index.ts, while the Vite build pipeline is defined in apps/web/vite.config.ts. These TypeScript files demonstrate how the frontend handles navigation and asset compilation.

Development Orchestration

Local development relies on Docker Compose to synchronize both environments. The docker-compose.yml at the repository root orchestrates the Python (Django) and Node (TypeScript) services, ensuring the backend API and frontend assets communicate seamlessly during development.

Summary

• Python (Django) handles the backend API, authentication, and database models in the apps/api/ directory.
• TypeScript (React) powers the interactive UI, state management, and routing in the apps/web/ directory.
• Key entry points include apps/api/plane/wsgi.py for the backend and apps/web/vite.config.ts for the frontend build system.
• The repository uses docker-compose.yml to unify both language environments for local development.

Frequently Asked Questions

Is makeplane/plane written entirely in Python?

No. While the backend API and business logic are written in Python using Django, the frontend application is built separately using TypeScript and React. The repository is a full-stack project combining both languages to separate server logic from client interactions.

Does Plane use JavaScript or TypeScript?

Plane uses TypeScript for all frontend code. Files like apps/web/core/store/user/profile.store.ts and apps/web/vite.config.ts leverage TypeScript to provide compile-time type safety and enhanced developer tooling.

What backend framework does makeplane/plane use?

The backend uses Django, the Python web framework. This is evident in the apps/api/plane/wsgi.py entry point and the class-based views found in apps/api/plane/web/views.py.

How are the Python and TypeScript codebases organized?

The repository follows a monorepo structure with apps/api/ containing Python code for the backend and apps/web/ containing TypeScript code for the frontend. The docker-compose.yml file at the root coordinates both services during development.

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