Colanode: Open Source Collaboration & Communication

What is Colanode?

Colanode is an open-source, local-first collaboration workspace that combines real-time chat, rich text pages, and customizable databases into one platform that individuals and teams can self-host to keep full control of their data.

What it is

Colanode is a TypeScript platform, licensed under Apache-2.0, that ships as a client application and a self-hosted server. The client runs as a web app or as an Electron desktop app, and a single installation can connect to multiple servers, each holding one or more workspaces for different teams or projects. It lives in the team collaboration ecosystem and is positioned as an open-source, local-first replacement for Slack and Notion: real-time messaging, rich text pages and wikis, customizable databases with table, kanban and calendar views, and file management inside secure workspaces.

The problem it solves is ownership and continuity. In the local-first workflow, every change is written to a local SQLite database first and then synced to the server by a background process, so work continues when the laptop or the server goes offline. Reads also happen locally, giving immediate access to content the user has permission to view. Concurrent edits on pages and database records are handled by Conflict-free Replicated Data Types (CRDTs) powered by Yjs, which merges simultaneous updates; deletions are tracked as specialized transactions. Messages and file operations do not support concurrent editing and use simpler database tables.

Key capabilities

Real-time chat for teams and individuals, with messages stored in simpler database tables rather than CRDT structures.
Rich text pages for documents, wikis, and notes, using an editor modeled on Notion.
Customizable databases with structured data, custom fields, and dynamic views in table, kanban, and calendar formats.
File management inside workspaces, with the backend selected through STORAGE_TYPE: local filesystem by default, plus S3-compatible, Google Cloud Storage, and Azure Blob Storage.
Local-first sync backed by a local SQLite database and a background synchronization process.
Concurrent editing of pages and database records through Yjs-based CRDTs, including deletions tracked as specialized transactions.
One app connecting to multiple servers and workspaces, available as a web client or an Electron desktop app.

Who uses it and how

Individuals and small projects that want chat, notes, and structured data in one place instead of several separate tools.
Teams that manage projects together and need shared pages, databases, and files in the same workspace.
Larger organizations collaborating across departments, using the multi-server and multi-workspace model to separate teams or projects.
Self-hosters with existing infrastructure: the hosting/ folder provides a Docker Compose file and deployment configurations, while hosting/kubernetes/ provides Helm charts and documentation for Kubernetes.
Teams working offline or on unreliable connections, where the local SQLite database and background sync keep work moving until connectivity returns.

Getting started

Fastest path is the hosted web app at app.colanode.com, which needs no installation; the desktop app is available from the downloads page for better performance. To self-host, use the Docker Compose file and deployment configurations in the hosting/ folder, or the Helm charts in hosting/kubernetes/, running the Colanode server API from its published Docker image.

How it compares

No list of paid products is supplied, but the project's own framing places it directly against Slack and Notion as an open-source, local-first alternative. The differences it claims are structural rather than cosmetic: Apache-2.0 licensing, a server the operator hosts, local SQLite storage with background synchronization, and Yjs-based CRDT collaboration instead of a purely server-side model.

When to use it — and when not to

Self-hosting means operating Postgres with the pgvector extension, Redis (or a Redis-compatible service such as Valkey), a storage backend, and the server API container. The web app is explicitly in early preview and may produce bugs or browser compatibility issues, so anyone needing a stable browser experience should install the desktop app or wait. The cloud servers are in beta and free for now, with pricing to be announced, so cost should not be treated as settled.

project readme (upstream, from github) — read inline

Colanode

Open-source & local-first collaboration workspace that you can self-host

Colanode is an all-in-one platform for easy collaboration, built to prioritize your data privacy and control. Designed with a local-first approach, it helps teams communicate, organize, and manage projects—whether online or offline. With Colanode, you get the flexibility of modern collaboration tools, plus the peace of mind that comes from owning your data.

What can you do with Colanode?

Real-Time Chat: Stay connected with instant messaging for teams and individuals.
Rich Text Pages: Create documents, wikis, and notes using an intuitive editor, similar to Notion.
Customizable Databases: Organize information with structured data, custom fields and dynamic views (table, kanban, calendar).
File Management: Store, share, and manage files effortlessly within secure workspaces.

Built for both individuals and teams, Colanode adapts to your needs, whether you're running a small project, managing a team, or collaborating across an entire organization. With its self-hosted model, you retain full control over your data while enjoying a polished, feature-rich experience.

Colanode preview

How it works

Colanode includes a client app (web or desktop) and a self-hosted server. You can connect to multiple servers with a single app, each containing one or more workspaces for different teams or projects. After logging in, you pick a workspace to start collaborating—sending messages, editing pages, or updating database records.

Local-first workflow

All changes you make are saved to a local SQLite database first and then synced to the server. A background process handles this synchronization so you can keep working even if your computer or the server goes offline. Data reads also happen locally, ensuring immediate access to any content you have permissions to view.

Concurrent edits

Colanode relies on Conflict-free Replicated Data Types (CRDTs) - powered by Yjs - to allow real-time collaboration on entries like pages or database records. This means multiple people can edit at the same time, and the system gracefully merges everyone's updates. Deletions are also tracked as specialized transactions. Messages and file operations don't support concurrent edits and use simpler database tables.

Get started for free

The easiest way to start using Colanode is through our web app, accessible instantly at app.colanode.com. Simply log in to get started immediately, without any installation. Please note, the web app is currently in early preview and under testing; you may encounter bugs or compatibility issues in certain browsers.

For optimal performance, you can install our desktop app, available from our downloads page. Both the web and desktop apps allow you to connect to any of our free beta cloud servers:

Colanode Cloud (EU) – hosted in Europe.
Colanode Cloud (US) – hosted in the United States.

Both cloud servers are currently available in beta and free to use; pricing details will be announced soon.

Self-host

If you prefer to host your own Colanode server, check out the hosting/ folder which contains the Docker Compose file and deployment configurations. For Kubernetes deployments, see the hosting/kubernetes/ folder which includes Helm charts and additional documentation. Here's what you need to run Colanode yourself:

Postgres with the pgvector extension.
Redis (any Redis-compatible service will work, e.g., Valkey).
Storage backend for user files. Colanode defaults to local filesystem storage, but you can switch to S3-compatible, Google Cloud Storage, or Azure Blob Storage backends by setting STORAGE_TYPE.
Colanode server API, provided as a Docker image.

Configuration model

The server image now ships with a full config.json, so most defaults are ready to go without touching env vars.
The config file is the single source of truth. Use env://VAR_NAME to pull sensitive values from env vars, or file://path/to/secret.pem to inline the contents of a mounted file (append ? to make either optional). Only POSTGRES_URL and REDIS_URL are required out of the box.
To customize settings:
1. Copy apps/server/config.json, edit it, and mount/bind it when using Docker Compose (see hosting/docker/docker-compose.yaml).
2. For Helm, enable colanode.configFile.enabled and pass your file via --set-file colanode.configFile.data=./config.json (details in hosting/kubernetes/README.md).
3. Keep secrets as env vars so you don't have to bake them into JSON; the loader resolves env:// pointers at runtime.

Environment variables no longer override regular config fields—only values explicitly tagged with env:// are read from the environment. Refer to hosting/docker/docker-compose.yaml and hosting/kubernetes/README.md for mounting instructions and the handful of required secrets.

Running locally

To run Colanode locally in development mode:

Clone the repository:

git clone https://github.com/colanode/colanode.git
cd colanode

Install dependencies at the project root:
```
npm install
```
Start the apps you want to run locally:

Server
```
cd apps/server

# Copy the environment variable template and adjust values as needed
cp .env.example .env

npm run dev
```
To spin up the local dependencies (Postgres, Redis, and Mail server) with Docker Compose—using filesystem storage by default—run this from the project root:
```
docker compose -f hosting/docker/docker-compose.yaml up -d
```
When you prefer an S3-compatible backend locally, enable the optional MinIO service with the s3 profile:
```
docker compose -f hosting/docker/docker-compose.yaml --profile s3 up -d
```
The compose file includes a server service. When you want to run the API locally with npm run dev, comment out (or override) that service so only the supporting services are started.

Web
```
cd apps/web
npm run dev
```
Desktop
```
cd apps/desktop
npm run dev
```

Testing

Colanode includes tests for both server and web.

Server tests

From apps/server:

npm run test

Server tests use Testcontainers for Postgres and Redis, so Docker must be running. See apps/server/README.md for details.

Web tests

From apps/web:

npm run test

License

Colanode is released under the Apache 2.0 License.

Frequently asked questions

Is Colanode free to use?

Colanode is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Colanode do?

Self-hosted team workspace with chat, docs, and databases

What is Colanode written in?

Colanode is primarily written in TypeScript. Its source is publicly available at https://github.com/colanode/colanode, and it has 5,141 GitHub stars.