# What Programming Language is makeplane/plane Written In?

> Discover the programming languages behind MakePlane Plane. Explore the Python backend with Django and the TypeScript frontend with React

- Repository: [Plane/plane](https://github.com/makeplane/plane)
- Tags: programming-language-info
- Published: 2026-06-25

---

**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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/apps/api/plane/web/views.py) contains handlers like `HealthCheckView` that demonstrate Django view patterns:

```python

# 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](https://github.com/makeplane/plane/blob/preview/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/apps/web/core/store/user/profile.store.ts) file implements a `ProfileStore` class using `makeAutoObservable` to manage user data reactively:

```typescript
// 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](https://github.com/makeplane/plane/blob/preview/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`](https://github.com/makeplane/plane/blob/main/apps/web/app/routes/redirects/index.ts), while the Vite build pipeline is defined in [`apps/web/vite.config.ts`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/apps/api/plane/wsgi.py) for the backend and [`apps/web/vite.config.ts`](https://github.com/makeplane/plane/blob/main/apps/web/vite.config.ts) for the frontend build system.
- The repository uses [`docker-compose.yml`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/apps/web/core/store/user/profile.store.ts) and [`apps/web/vite.config.ts`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/apps/api/plane/wsgi.py) entry point and the class-based views found in [`apps/api/plane/web/views.py`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/docker-compose.yml) file at the root coordinates both services during development.