Macro Setup: Self-Host the Open Source Slack and Linear Rival

Macro is a team workspace that folds email, chat, docs, tasks, calls and CRM into one Rust application, and it is the fastest-climbing installable tool on GitHub trending today with roughly 1,239 stars in a day against 2,729 total. If you want it running on your own hardware, budget an afternoon rather than ten minutes: the self-host path needs Nix and Docker, and the payoff is a single AGPLv3 binary set that replaces five SaaS subscriptions.

• Three install paths exist and they are not equivalent: the hosted app, a desktop build, or a full local stack from source.
• The local stack is one command once Nix and Docker are in place, and it boots Postgres, Redis, LocalStack, OpenSearch, Kafka and FusionAuth alongside the app.
• There is no Windows desktop binary in the current release, only an Apple Silicon .dmg and an x86_64 Linux AppImage.
• Licensed AGPL-3.0 with no open-core split, and the maintainers point self-hosters at the license terms rather than a paywalled edition.

What is Macro and why is it trending?

Macro comes out of a New York and Toronto team that dogfooded it internally at around 15 people for two years before opening the source. The README is unusually specific about the problem: they ran Slack, Linear, Notion, HubSpot and Superhuman, scaled a previous venture to about 20 people, and watched the company get "held together by MCP and Zapier" until it stopped being computable.

RelatedKaneo Setup: Self-Host a Free Jira Alternative in 10 Minutes

Technically it is a SolidJS client on a Rust backend: 167 crates, 42 deployable services, and a bidirectional graph as the storage model rather than per-product databases with sync jobs between them. That graph is the actual feature. An @mention of a task inside an email creates a link both objects know about, so a customer complaint traces forward to the ticket, the agent that picked it up and the pull request that closed it. The repository went public in November 2025, and the trending spike tracks with desktop builds landing in the August 12 release.

Which install path should you pick?

Start honest about what you want. If you are evaluating the product, the hosted app at macro.com/app is the fast path, and the docs claim a fresh account to working setup in about 15 minutes. If you want a native client, the current release v2026.8.12.0 ships two desktop assets and only two:

# macOS, Apple Silicon (28.3 MB)
Macro-2.5.0-aarch64-darwin.dmg

# Linux, x86_64 (76.8 MB)
Macro-2.5.0-x86_64-linux.AppImage

# checksums published alongside both
macro-dmg-SHA256SUMS
macro-appimage-SHA256SUMS

Windows and Intel Mac users have no binary here, and neither does anyone on ARM Linux. Releases only started carrying desktop artifacts on August 12; every tag before that shipped a web-app tarball alone, so the gaps look like a build matrix that has not finished growing. iOS has a real App Store app; Android is listed as coming.

How do you run the whole stack locally?

Here is where the prerequisites bite. You need the Nix package manager and Docker with the Compose v2 plugin, and nothing else, because the Nix shell supplies the rest of the toolchain:

$ git clone https://github.com/macro-inc/macro.git
$ cd macro
$ nix develop

If nix develop refuses to start, it wants experimental features that are off by default. Enable them for a single run:

nix develop --extra-experimental-features nix-command --extra-experimental-features flakes

To make that permanent, put experimental-features = nix-command flakes in ~/.config/nix/nix.conf. Inside the shell you have just, Cargo, the Rust toolchain, Bun, sqlx, zig and cargo-zigbuild without installing any of them. Run the preflight check before the first boot; it tests the Docker daemon and reports which required ports are already taken:

$ just doctor-local

Then start the stack. The --no-doppler flag is the one you want; Doppler is the team's secrets manager and the docs are explicit that most contributors do not have access, so the local configuration is code-defined with dummy AWS credentials and fixed test secrets:

$ just run_local --no-doppler

That builds the Rust services, brings up the container infrastructure, then starts the backend, proxy and frontend, printing the URLs when it finishes. While attached, r rebuilds and reloads changed Rust services and q stops the stack. Use q rather than closing the terminal: it removes the containers in one pass instead of leaving a stale stack behind.

Registration is passwordless and creates the user on demand, so sign up with any address you like. The one-time code does not go to a real inbox: it lands in Mailpit at http://localhost:8025. Read it there.

How do you get something worth clicking into it?

An empty workspace tells you nothing about a product whose entire argument is cross-object linking. The seed CLI exists for exactly this, building users, teams, channels, projects, documents, tasks, chats, calls, emails and messages with realistic permissions:

$ just seed-scenario apply --file seed/scenarios/team-perms.json

It creates a FusionAuth account per persona and prints a login link for each, shaped like http://alice.localhost:3000/app/[email protected]. Every persona hostname keeps its own cookie jar, so you can drive several side by side in ordinary tabs against one stack and watch how permissions actually behave. just seed-scenario matrix then checks the expected access level for every user and entity pair against the live database.

For a stack that survives closing the terminal, headless mode builds the frontend once and serves it statically behind the proxy:

RelatedBlock Buzz Setup: Self-Host the AI Agent Workspace

$ just stack up
$ just stack status --json
$ just stack update
$ just stack down

And if you already run coding agents, the MCP endpoint takes one line and works against the hosted workspace:

claude mcp add --transport http macro https://mcp-server.macro.com/mcp

How does it compare with Slack, Linear and Notion?

The incumbents each win their own column on maturity, and nothing here changes that. What Macro is selling is the row about links, and that row is the only one a Zapier subscription cannot buy you.

What are the gotchas before you rely on it?

Five, and they are the difference between a clean install and a confused evening. First, the --no-doppler stack boots with deterministic stubs for every config value, so the services start but the integrations behind them do not work. Google login and Gmail sync, GitHub login, Stripe billing and CloudFront signed URLs stay inert until you supply real keys through just run_local --no-doppler --env-file ./local.env. Auth, documents, email and search work fine; the connectors do not.

Second, macOS port conflicts fail confusingly. Port 8080 belongs to the Apple WebDriver service when remote automation is on, and 8090 gets grabbed by other dev servers. The frontend loads, but API calls hit the wrong process and return HTML where you expected JSON. Move the whole stack rather than hunting the offender: just doctor-local --instance test --port-base 31000 checks a free window, then run and seed with the same two flags every time, or the seed CLI reads the wrong database.

Third, three services (sync_service, lexical_service, websocket_service) have Docker-built images that are not rebuilt by default, so changing one leaves the stack quietly serving a stale image until you restart with --build-aux-services. Fourth, AGPLv3 is an obligation rather than a formality: modify Macro for anything network-facing and the copyleft terms follow, though the maintainers offer relicensing through [email protected]. Fifth, this went public nine months ago and is being pitched as your company's system of record. Seed a scenario, click through it, and confirm the migration story out of it before you move a real team.

Our take

Most all-in-one workspaces fail because they are five mediocre products sharing a nav bar. Macro bets the interesting part is underneath, in a graph where an email and a task are the same class of object, and a 15-person company running on it for two years before publishing is better evidence than any feature list. The catch is that the honest self-host path is not the ten-minute install this format usually covers.

Try the hosted app first to decide whether the model clicks, then stand up the local stack if it does. That order costs nothing and saves the afternoon when the answer is no. What earns the stars, and what would keep them, is the licensing: AGPL with the whole thing in the repository and no reserved edition is a rarer commitment in this category than the workspace itself.

Original analysis by GenZTech. Tool documentation: macro-inc/macro on GitHub.