Feb 10, 2024 6 min read

What is Commune?

'Village' by spacegoblin

Commune is an open source community platform, specifically designed for publicly available communities. We're designing tools for projects that thrive in an open environment, perpetually improved by their wisdom of the crowd.

Built as a Matrix server extension (Synapse only for now; Conduit is coming) combined with a custom client to make use of said extensions, Commune inverts some major norms of the mainstream Matrix experience:

Web-readable channels and threads that are easily shared as links and tended to in a search-engine friendly digital garden - not hidden behind authentication. ✅ mostly done
Shared interest discoverability across spaces via federated webrings. 🚧 wip
Opt-in everything (encryption, federation, notifications et.al.) for ease of onboarding. Our top priority is getting people into a shared space together with minimal friction. 🚧 wip
Baked in Discord-interop for easy onboarding of non-Matrix users. 🚧 wip

👆 proper blog posts are coming for all of the above.

With the Matrix protocol as a stable backbone, Commune acts as an accessibility layer on top that optimizes for online community building by small and medium sized grassroots organisations, as opposed to the 'secure & private' focus of Element which targets governments and enterprises.

See this comparison for a better idea of how Commune (once v1.0 is done) compares to other group chat & forum apps.

3-year Recap

This project started in earnest three years ago, when ahq / @ChurchOfTheSubgenius revealed Hummingbard, the first iteration of what is now Commune.

Back then it was basically a Reddit-alternative built with Matrix. In other words, a federated links-aggregator much like Lemmy, but based on the Matrix protocol instead of ActivityPub.

Erlend: I had recently quit my job at Discourse as VP of Community, where I first joined as Community Advocate. Even though I wasn't actively looking to get into another community platform project straight out of the gate, Hummingbard happened to tick a Matrix-shaped box that I'd been keeping a close eye on ever since it became clear to me that the dual chat/forum paradigm was really a false dichotomy.

So I reached out, and we started chatting together on the daily in a Matrix DM.

Over the course of that year the Hummingbard design underwent several minor pivots as we figured out our best starting point. We designed for what we found lacking in the community platform landscape, combined with a pragmatic look towards commercialization for the purpose of long-term sustainability.

Supporting Reddit-like (nested) conversations and link-aggregation remained appealing, but not so much as a focal point of the product, seeing as even Reddit itself was clearly struggling to make that business model work in a user-friendly way.

By the end of 2021 we had settled on the design later described in Communal Bonfires, and a new name: Commune 🏕️

By mid-2022 we had another proof-of-concept up and running. Sadly the effects of the pandemic were still running rampant, causing all sorts of havoc in Bangladesh where ahq resides. Due to numerous life-altering calamities as well as some painfully protracted power outages, we'd sometimes go months without contact.

Mid-way into 2023, after a long hiatus, we regained regular contact and resumed active development of the project. The road here has been eventful to say the least, but our commitment to this project and the friendship that underpins it has never been stronger!

Commune 2024

This year will be our big push towards v1.0 of Commune. With the help of a grant from NLnet, we've got a tentative roadmap for what's coming:

Generic Matrix Client
Federation between Matrix instances
Private spaces/boards and Encrypted DMs
Essential Commune improvements
Deeply integrated Discord integration
Social login support, OIDC
Simplify self-hosting deployment (depends on upstream)
Basic ActivityPub support for interacting with the fediverse

To give you an idea of where this work will happen, we'll provide brief technical overview of Commune's inner workings.

Commune application

Our codebase is divided into two core repositories, server-backend and client-frontend.

Server

commune-server functions as a middlelayer between a Matrix homeserver (Synapse/Conduit) and the Commune client. It enables our client to interface with the Matrix protocol whilst also layering on top additional features that do not yet exist in Matrix, such as web-readable rooms. The server builds an additional API on top of the matrix client-server API, which allows for faster querying of matrix events, and more complex relationships between events (nested comments, threads, backlinks).

The current MVP implementation of commune-server is written in Go. In preparation for a production-grade setup, we've started porting our server to Rust-lang in commune-rs.

Put simply, our reasoning for this is closer alignment with the modern Matrix stack, which is betting big on Rust with flagship projects like matrix-rust-sdk, matrix-authentication-service, matrix-rich-text-editor, matrix-rust-sdk-crypto-wasm and vodozemac.

Client

commune-client is a special kind of Matrix client, for a couple reasons.

Firstly, while requiring commune-server for all its features, commune-client can also (soon) be used as a regular Matrix client.

When used as a regular Matrix client, commune-client can make any world_readable Matrix room publicly accessible, without need for user authentication. Although this fallback native matrix client will lack a lot of Commune's extra features, it still serves the purpose of making web-readable Matrix spaces and rooms. commune-client talks to a matrix homeserver directly, using matrix-js-sdk.

Current state

We currently have two complete instances of Commune running at shpong.com and app.commune.sh. These instances federate with each other. With the unknown unknowns out of the way in this proof-of-concept, we're now making a minimum viable product to put in users' hands.

Commune platform

Self-hosting is important to us, but 99.9% of internet users have no interest in managing their own cloud applications. Even the majority of tech-savvy people who could self-host would much rather use a managed service, so long as their freedom to exit is guaranteed by safeguards like open source code and interoperable protocol standards.

Hence the existence of commune.sh, our hosted platform service for easy setup of Commune instances. Two different products will eventually be on offer.

preview.commune.sh

As mentioned, the basics of Commune's functionality can be achieved strictly client-side, making it perfectly suited for an MVP.

preview.commune.sh will use commune-client to provide an add-on service for existing Matrix communities that want to make their space/rooms web-readable. This process can of course only be opted into by admins, who in turn will be required to clearly notify all tenants when their instance becomes publicly available.

commune.sh

Once we’ve got Preview up and running, our focus will turn towards the complete Commune platform. Running as a regular Software as a Service, this multi-site instance is for community founders who want to set up a brand new space from scratch.

That means we'll be hosting our own Matrix homeserver, commune-server and commune-client all in one seamless experience to be competitive with the usability of mainstream group chat applications.