UnInbox: Open Source Email & Communication

What is UnInbox?

What it is

UnInbox is an open-source communication infrastructure project for teams and professionals, built in the TypeScript and Next.js ecosystem and positioned as a modern replacement for outdated email tools. It presents itself as a web application that reimagines email communication for current workflows, while still working with existing email infrastructure or replacing it entirely.

The concrete problem it addresses is that email has remained structurally similar since its early use, but communication has become noisier, more mobile, more remote, and more collaborative. UnInbox aims to reduce that mismatch by adding native features such as team collaboration, conversation notes, and a new sender screener, so ordinary email traffic can be handled through a more purposeful workflow instead of a traditional inbox.

Key capabilities

It provides a web application for email communication with native team collaboration, conversation notes, and a new sender screener.
It works with current email infrastructure or replaces that infrastructure entirely.
It exposes a public API and miscellaneous tooling through Hono.
It uses tRPC to provide typesafe APIs within the application.
It uses DrizzleORM with MySQL for database access and schema synchronization.
It provides front-end and backend modules built with Next.js, React, and Tailwind.
It supports local development and deployment workflows with Node.js, pnpm, and Docker.

Who uses it and how

Teams and professionals can use it as a web-based platform for handling email conversations and collaborative communication.
Developers can clone the repository, install dependencies with pnpm, start Docker containers, push the database schema, and run the app locally.
Self-hosters can deploy UnInbox in production after completing manual email configuration and consulting the project Discord for setup guidance.
Users can try the hosted application at app.uninbox.com while the project continues adding features and infrastructure.

Getting started

Typical local setup uses cloning the repository, installing dependencies with pnpm, copying the example environment file, starting Docker containers, pushing the database schema, and running pnpm run dev. A hosted option is available at app.uninbox.com, while self-hosting requires additional manual email configuration.

When to use it — and when not to

Use UnInbox when a team wants a self-hostable, open-source email communication platform with native collaboration features and a modern web stack, especially if it is evaluating an alternative to hey.com, front.com, or missiveapp.com. Do not use it when a low-maintenance self-hosted deployment is required, because self-hosting needs MySQL, manual email configuration, and ongoing attention while features and infrastructure are still being developed.

project readme (upstream, from github) — read inline

UnInbox

The Open Source Communication Infrastructure

To our Website & App »

UnInbox Twitter · UnInbox Discord Server

:construction: Current Status

UnInbox is Live! We are working on more features and infrastructure to make UnInbox better. Please join our Discord community to get the latest updates and to provide feedback. Join at app.uninbox.com.

About

Our core infrastructure is designed from the ground up for effective communication between you and the rest of the world.

The webapp provides a flavoured experience of what email communication would be if it was re-imagined for how we communicate today.

Features like "team collaboration", "conversation notes" and "new sender screener" are native, making communication easier and more intuitive.

Built to work with your current email infrastructure or replace it entirely.

We're not here to kill email, we're bringing it up to date, killing inboxes along the way.

UnInbox isn't another email service, its a better way to do email.

And email is just the start

Why

The first email was sent almost 45 years ago (1979). Before the invention of the mobile telephone.

Communication workflows have changed dramatically since then, but the email experience has remained the same.

The volume of emails we receive has exploded in recent years, with more noise than actual conversations.

Email is not built for today's noisy, remote, highly collaborative world.

But email is universal, so we can't force the world to replace it.

Instead, we're detaching from its legacy underpinnings, to build something modern on top.

Tech Stack

UnInbox is built with the following epic technologies & tools:

Next JS React based FrontEnd & Backend + modules
Hono Public API + Misc tooling
Tailwind CSS Engine
tRPC Typesafe APIs
DrizzleORM ORM + MySQL

Running Locally

To get a local copy up and running, follow these simple steps.

Prerequisites

Here is what you need to be able to run UnInbox locally.

Node.js (Version: >=20.x)
NVM (Node Version Manager) (see https://github.com/nvm-sh/nvm)
Docker
pnpm (Version >= 9.x) (see https://pnpm.io/installation)

Setup

Clone the repo into a public GitHub repository (or fork https://github.com/un/inbox/fork). If you plan to distribute the code, keep the source code public to comply with AGPLv3. To clone in a private repository, contact us to acquire a commercial license
```
git clone https://github.com/un/inbox.git
```
If you are on Windows, run the following command on gitbash with admin privileges:
> git clone -c core.symlinks=true https://github.com/un/inbox.git
See docs for more details.
Go to the project folder
```
cd UnInbox
```
Check and install the correct node/pnpm versions
```
nvm install
```
Install packages with pnpm
```
pnpm i
```
Set up your .env.local file
- Duplicate .env.local.example to .env.local. This file is already pre-configured for use with the local docker containers
  
  mac
```
 cp .env.local.example .env.local
```
  windows
```
 copy .env.local.example .env.local
```
Start the docker containers
```
pnpm run docker:up
```
Sync the schema with the database:
```
pnpm run db:push
```
In another terminal window, start the app and all services
```
pnpm run dev
```

Self Hosting

Self hosting will be possible, but requires some additional manual configuration for email. Please check out Discord community for information on how to self-host UnInbox in production

Frequently asked questions

Is UnInbox free to use?

UnInbox is open source. 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 UnInbox do?

Transform team email into efficient collaborative workflows

What is UnInbox written in?

UnInbox is primarily written in TypeScript. Its source is publicly available at https://github.com/un/inbox, and it has 1,757 GitHub stars.