Chatto Goes Open Source: Why a 3ms Chat App Rewrites the Rules of Team Messaging

When was the last time you opened a chat app and felt a delay? Probably within the last hour. Slack, Teams, Discord—they all suffer from a kind of gravitational drag, a half-second of spinner before messages appear, a beat of hesitation when switching channels. We've been trained to accept it as the cost of modern collaboration.

But what if that lag isn't inevitable? What if the architecture itself is to blame?

Enter Chatto, a group and team chat application that its creator, Henk, describes as “the snappiest chat application you've ever used.” Until this week, it was a closed-source side project. Now, it's open source. And the reason it's fast isn't magic—it's a design choice that major incumbents have been too slow to make.

The Architecture of Snappiness

Chatto's secret sauce lives in its message broker: NATS. Unlike the HTTP polling or WebSocket-based approaches used by most chat apps, NATS is a lightweight publish-subscribe system built for speed. It's so lean that messages can travel from sender to receiver in under 3 milliseconds—even on modest self-hosted hardware.

But speed is only half the story. NATS also ships with a built-in stream persistence engine. That means messages are durable without requiring a separate database like PostgreSQL or Redis for every read and write. The broker itself handles both routing and storage, cutting out a layer of network hops that typically add latency.

Why "No Intermediate Storage" Matters for Privacy

Here's where it gets interesting for anyone concerned about data sovereignty. Because NATS can stream messages directly to consumers without writing them to an intermediate disk by default, there's no forensic recovery trail on the broker itself. If a message is consumed and not explicitly persisted, it's gone—no disk writes, no journal files to dig through. For teams handling sensitive communications (legal, healthcare, defense), this is a radical departure from Slack's model, where every message is written to multiple storage tiers and retained indefinitely.

A Concrete Use Case: The Remote Team That Ditched Slack

Consider a 40-person remote design agency. They've been paying Slack roughly $800 per month. They're frustrated by the 2-second delay every time they switch channels during a real-time critique. They try Chatto on a $20/month VPS.

Day one: the latency disappears. A designer posts a mockup; three teammates react with emoji before the message even finishes rendering on their screens. They create channels for projects, and because Chatto uses NATS, every client gets a persistent subscription—no polling, no reconnection storms when someone's Wi-Fi dips. The agency cuts its monthly bill by 97% and gains a feature Slack can't offer: complete control over message retention. If a client contract requires deleting all messages after 30 days, they simply set the stream policy and sleep soundly.

This isn't a fantasy. It's the natural outcome of an architecture that treats speed and privacy as first-class concerns, not afterthoughts.

Why Incumbents Can't Follow

You might wonder: If NATS is so great, why don't Slack, Teams, or Discord just switch? The answer is architectural inertia. These platforms are built on decades of accumulated infrastructure: custom message queues, sharded databases, global CDNs, and compliance tooling that assumes every message must be logged, indexed, and searchable forever.

Rewriting that stack to use a broker like NATS would require years of engineering and risk breaking every integration, every bot, every enterprise compliance checkbox. For a public company like Salesforce (Slack's owner), the cost of change is higher than the cost of a few hundred milliseconds of user frustration.

Chatto, by contrast, started from a clean sheet. Its author built it for a single purpose: be fast. By choosing NATS from the beginning, he avoided the accretion of complexity that plagues older systems.

The Open Source Moment

Making Chatto open source is a bet. It says: the best way to compete with entrenched giants is to give away the blueprint. Developers can now inspect every line, suggest improvements, and—crucially—self-host it without licensing fees.

For the curious professional, this is a rare opportunity to see how a modern chat system works under the hood. The codebase is small enough to understand in an afternoon. The dependencies are minimal. And the lessons apply beyond chat: any real-time application (IoT dashboards, live collaboration tools, financial tickers) can benefit from the same NATS-based pattern.

Getting Started (In One Sentence)

Clone the repo, run docker compose up with a NATS config, and you'll have a working chat server in under five minutes—see the docs for details.

The Takeaway

Chatto isn't just another open source chat app. It's a live demonstration that the bloat we've accepted in team communication is a choice, not a technical necessity. The incumbents won't change—their business models depend on complexity, lock-in, and data hoarding. But now you have a 3ms alternative that proves a simpler, faster, more private path exists. The question isn't whether Chatto will replace Slack. It's whether you'll keep paying for lag.