cabal.chat

Cabal is a private, peer-to-peer chat platform for friends and communities that works offline, built by volunteers and without owners. The Cable protocol it uses has been implemented independently in Erlang by a project friend known as Cryptix. That implementation, called caberl, includes both a node implementation and an early TUI (terminal user interface) client, and it is hosted at https://git.sr.ht/~cryptix/caberl/. This matters because it demonstrates that Cable is not tied to a single programming language ecosystem — the protocol can be implemented in any language, which opens the door to clients and nodes beyond the original stack.

What the Erlang implementation includes

According to the project's 2025 end-of-year update, the Erlang work covers two pieces:

• A node implementation — the part that participates in the peer-to-peer network.
• An early TUI client — a terminal-based way to interact with it, described as early, so expect rough edges rather than a finished app.

The source lives at https://git.sr.ht/~cryptix/caberl/. The update credits Cryptix as "a good friend of the project," which is consistent with Cabal's framing as a volunteer effort without owners.

Why a second-language implementation is notable

Cabal describes Cable as a protocol that "can be implemented in any programming language ecosystem." The Erlang implementation is a concrete example of that claim rather than just an aspiration. For anyone evaluating Cabal, the practical implication is:

• The chat network is defined by a protocol, not by one app.
• Independent implementations can appear in different languages and runtimes.
• A terminal client is possible, which fits Cabal's stated goal of being usable in alternative terminal browsers and by security-minded people who avoid JavaScript.

How to look at it

If you want to inspect or try the Erlang work:

1. Open https://git.sr.ht/~cryptix/caberl/.
2. Look for the node implementation and the TUI client as separate components.
3. Treat the TUI client as early — the project itself labels it that way, so don't expect a polished end-user experience yet.

If your interest is Cabal generally rather than Erlang specifically, the main project site is cabal.chat, where the download and the 2025 end-of-year update are linked. The update also notes a redesigned website, not yet launched on the main domain, with a preview hosted by Codeberg at https://cabal.codeberg.page/.

Cabal is a chat platform for friends and communities that works offline, is private and peer-to-peer, and is run by volunteers without owners. In practice, "offline" does not mean messages travel through the air with no connection at all — it means the app keeps working on your device when you have no internet, and your messages sync directly with other participants once a connection exists. The peer-to-peer design means there is no central server holding the conversation; the people in the chat are the infrastructure.

What "offline" actually means here

Cabal's own description is that it is "a chat platform for friends and communities that works offline." The useful way to read that:

• You can open the app and read and write in a channel without an active internet connection.
• Your messages are stored locally on your machine, not fetched from a remote server each time you open the app.
• When connectivity returns, your local state reconciles with the peers you can reach.

This is different from a typical hosted chat app, where losing the network usually means the interface goes stale or refuses input. With Cabal, the local copy is the working copy.

Why there is no central server

Cabal is peer-to-peer, so the conversation is not hosted on a company's machines. Each participant holds a copy of the chat's data and exchanges updates directly with other participants. Two consequences follow:

1. No owner can shut the room down or read it from a single point. The project describes itself as "by volunteers and without owners," which matches the architecture — there is no operator account with privileged access to everyone's messages.
2. Availability depends on the peers, not a service. If nobody you can reach is online, you are effectively chatting with your local copy until a peer becomes reachable again.

That second point is the trade-off to understand before adopting it: decentralization removes the single point of failure and the single point of control, but it also removes the always-on server that would otherwise hold messages for you.

How messages move between participants

The mechanism is direct synchronization between peers rather than a client–server round trip. A message you write is added to your local copy of the chat, and peers you connect to receive that update and merge it into their own copies. Because each peer keeps its own copy, the same conversation can be reconstructed from any participant's device.

The protocol behind this is called Cable, and it is deliberately implementable in any programming language ecosystem. The project's 2025 retrospective notes that a friend of the project, Cryptix, built a standalone implementation of the Cable protocol in Erlang, including both a node implementation and an early TUI (terminal user interface) client. That matters for the offline/peer-to-peer question because it shows the sync layer is not tied to one app or one runtime — different clients can speak the same protocol and exchange the same chat data.

Where privacy comes from

Privacy here is a property of the decentralized design rather than a promise made by an operator:

• There is no central server collecting the conversation, so there is no single database to breach or hand over.
• Messages live on participants' own devices and move directly between them.
• The project is run by volunteers with no owner, so there is no commercial operator with an incentive to mine or monetize the content.

This is a structural argument, not a claim that the content is encrypted end-to-end in every configuration — the source material describes the platform as "private and peer-to-peer" without detailing encryption specifics, so treat "private" as meaning "no central party holds your chat," and verify any stronger cryptographic guarantees separately if that distinction matters to you.

A concrete example

Imagine a small group spread across two cities. One member is on a train with no signal and writes several messages in a channel. Those messages sit in her local copy of the chat. When she reaches a network and connects to another member who was online, the two copies reconcile and the messages propagate to the rest of the group as they come into contact with peers who already have them. Nobody had to run a server for this to work, and nobody had to be online at the same moment as everyone else.

What to check before relying on it

• Peer availability: since there is no always-on server, message delivery depends on peers being reachable at some point. Plan for delays in small or sparse groups.
• Client choice: the Cable protocol has multiple implementations (the Erlang node and TUI client are one example), so the exact offline behavior and interface depend on which client you use.
• Your threat model: "no central owner" and "end-to-end encrypted" are different guarantees. Confirm which one you actually need.

The short version: Cabal keeps the chat on your device, syncs it directly with the other people in the room, and needs no central server to exist — which is exactly why it keeps working when the network does not.

Cabal is a chat platform for friends and communities that works offline, is private and peer-to-peer, and is run by volunteers without owners. It is a fit if you want group chat that keeps working when the internet drops, and you are willing to download a client rather than sign up on a hosted service. It is not a fit if you need a managed cloud product with a company behind it.

What Cabal actually is

The project describes itself in three claims: it works offline, it is private and peer-to-peer, and it is built by volunteers with no owners. Those three points drive most of the practical differences from mainstream chat apps.

• Offline-capable. Chat is not dependent on a central server being reachable for you to read and write.
• Peer-to-peer. Participants connect to each other rather than to one company's servers.
• No owners. There is no company account to create, no subscription tier, and no vendor deciding what the platform does next.
• Download required. The site offers a download rather than a browser sign-up flow.

How it differs from typical chat platforms

The trade-off is visible in the project's own updates. In its 2025 end-of-year post, the team wrote that they had "been quiet as a project" because they are "regular people volunteering behind the project," and that life "has a way of making itself known in various ways, causing periods of downtime and rest in the project." If you need predictable release cadence and support, that is a real cost. If you value a platform that is not owned by anyone, it is the point.

What the ecosystem looks like

Cabal is not just one app. The protocol has been implemented independently, which matters if you care about the project outliving any single client.

• A standalone Erlang implementation. A friend of the project, Cryptix, built the Cable protocol in Erlang, including a node implementation and an early TUI (terminal user interface) client, published at https://git.sr.ht/~cryptix/caberl/.
• A redesigned website. A new site was designed with a team starting from an offer in 2022 and implemented in 2025. It is not yet live on the main domain, but a preview is hosted at https://cabal.codeberg.page/. The design contributors credited are A. V. Bridgwood, Freya Morgan, and Eileen Wagner.
• A content/template split. The old site was HTML that was "somewhat fragile to update." The new approach separates content (Markdown) from templates, and deliberately avoids requiring visitors to enable JavaScript so the site works in terminal browsers and for security-minded readers.

The Erlang work is the more consequential item: it shows the protocol can be implemented in different language ecosystems, not only the original one.

How to decide

Choose Cabal if:

• You want group chat for friends or a community that keeps working without a connection.
• You prefer peer-to-peer and private over centralized hosting.
• You are comfortable downloading and running a client.
• You accept volunteer-paced development, including quiet stretches.

Look elsewhere if:

• You need a hosted service with no installation.
• You need commercial support, SLAs, or a roadmap you can hold someone to.
• You want to sign up in a browser in under a minute.

Getting started

1. Go to cabal.chat and use the download link on the page.
2. Install and launch the client.
3. Join or create a community space for your group.
4. Verify offline behavior yourself: disconnect from the network and confirm you can still read and write in the space, then reconnect and confirm messages sync with the other participants.

The last step is the one worth doing before you commit a group to it, because offline and peer-to-peer behavior depends on the other participants being reachable at some point.

Open questions

The available project material does not state pricing, account requirements, or platform support for the download. Treat those as unconfirmed and check the download page directly rather than assuming the client is free or available on your platform.

Cabal's official site at cabal.chat is the place to start: it hosts the download entry point plus a running log of project news. From the same page you can reach the 2025 end-of-year update, the full posts archive, and an RSS feed for subscribing. If you want to see where the project is heading, a preview of the redesigned website is hosted separately on Codeberg.

Downloading Cabal

The homepage presents a download option directly. Cabal describes itself as a chat platform for friends and communities that works offline, is private and peer-to-peer, and is run by volunteers without owners — so the download you're looking for is the client for that network rather than a hosted sign-up service.

The page itself doesn't list platforms, package formats, or version numbers, so treat the download link as the entry point and check what it offers for your system.

Reading Project Updates

The site doubles as the project's news channel. As of the latest post, dated 2025-12-19, the visible update is the Cable 2025 retrospective, which covers:

• Cable in Erlang — a standalone implementation of the Cable protocol by Cryptix, including a node implementation and an early TUI client, published at https://git.sr.ht/~cryptix/caberl/
• A new website — designed with a team starting back in 2022 and implemented this year, not yet live on the main domain but previewable at https://cabal.codeberg.page/
• Why the site was rebuilt — the old HTML source was fragile to update, so the project moved toward separating content (Markdown) from templates, avoiding a Node.js requirement and keeping the site readable without JavaScript, including in terminal browsers

The retrospective also notes that the project has been quiet through the year because it's run by regular volunteers whose lives cause periods of downtime and rest.

Subscribing Instead of Checking Back

Two mechanisms let you follow updates without revisiting the site manually:

Both are linked from the homepage, so you can pick whichever fits how you already track projects.

What to Expect From the New Site

The Codeberg preview is a sneak peek, not the launched version — the project says improvements remain before it moves to the main domain. The design goals behind it are worth knowing if you care about how you'll read Cabal's documentation:

• Content stored as Markdown, separated from templates
• No JavaScript required to view pages
• Readable in alternative terminal browsers

That last point matters if you prefer lightweight or security-conscious browsing: the documentation should stay fully accessible without enabling scripts.

Cabal is run by volunteers, not a company, and it has no owners. The project describes itself as "private and peer-to-peer, by volunteers and without owners," so there is no central operator, no corporate parent, and no single person who decides what happens next. Governance is informal and community-driven: people contribute when they can, and the project moves at the pace that volunteer life allows.

What "no owners" means in practice

The phrase "without owners" is the clearest statement of Cabal's governance model. There is no entity that holds the platform, sells access to it, or sets policy from the top down. Instead:

• The software is built and maintained by regular people who volunteer their time.
• The project has no owner in the sense of a proprietor who can shut it down, change its terms, or monetize it unilaterally.
• Because it is peer-to-peer, there is no central server operator whose business model depends on the chat traffic.

This is a structural choice, not just a slogan. A peer-to-peer chat platform that works offline does not need a company in the middle, so the project does not have one.

How the project is actually governed

There is no published charter, board, or voting process in the available material. What the project does describe is a volunteer rhythm:

"We are regular people volunteering behind the project and so life has a way of making itself known in various ways, causing periods of downtime and rest in the project."

That sentence is the most concrete governance signal available. It tells you two things:

1. Decision-making is distributed among whoever is actively contributing. There is no full-time staff whose job is to keep a roadmap on schedule.
2. Progress is uneven by design. Periods of quiet or downtime are expected, not a sign that the project is abandoned.

The 2025 retrospective notes that the year was "quiet as a project" for exactly this reason. If you are evaluating Cabal for a community that needs predictable release cadence or formal support, that volunteer pace is the main trade-off to weigh.

Who contributes, and how outsiders fit in

Contributions come from volunteers and from people adjacent to the project. The retrospective credits specific named contributors for design and implementation work, including A. V. Bridgwood, Freya Morgan, and Eileen Wagner for website design and illustrations, and a contributor known as Cryptix for a standalone implementation of the Cable protocol in Erlang.

That pattern is the practical answer to "how is it governed": work happens when someone volunteers to do it, and the project publicly thanks them. If you want to contribute, the model is open in the sense that there is no gatekeeping company — but there is also no onboarding department. You would be joining a volunteer effort, not applying to a vendor.

What this means if you are deciding whether to use Cabal

The short version: Cabal is governed by the people who show up to work on it, and nobody owns it. That makes it resilient against commercial shutdown but dependent on volunteer energy, which is why the project itself frames quiet periods as normal rather than alarming.