Tuwunel

Self-hosted team communication, honestly reviewed. No marketing fluff, just what you get when you run your own Matrix server.

TL;DR

• What it is: A high-performance Matrix homeserver written in Rust — the official successor to conduwuit, which itself succeeded Conduit [README].
• Who it’s for: Privacy-conscious teams, self-hosted communities, and organizations migrating off Discord or Slack who want federated, end-to-end encrypted communication on infrastructure they control [README][2].
• Cost angle: Synapse (the Matrix reference implementation) is notoriously resource-hungry. Tuwunel runs on modest hardware — a $5–10/mo VPS handles a small-to-medium community, versus Slack Pro or Microsoft Teams licenses that compound per user [README].
• Key strength: Rust-native performance, minimal resource footprint compared to Synapse, and deployment simplicity that makes it the homeserver of choice for lean self-hosters [README][2].
• Key weakness: Young project — Synapse migration is still planned but not yet supported, the integration/bot catalog assumes you’re working within the existing Matrix ecosystem, and there are essentially no third-party benchmarks or reviews to consult yet [README].

---

What is Tuwunel

Tuwunel is a Matrix homeserver — the server-side component that powers your team’s chat, channels, file sharing, and calls when you choose to run Matrix instead of Discord, Slack, or Teams. A Matrix homeserver sits roughly where your email server sits in the email world: it handles your users’ accounts, stores messages, and federates with other servers in the global Matrix network.

What makes Tuwunel specifically worth covering is its lineage and technical approach. It’s written entirely in Rust, making it substantially lighter than Synapse (the reference implementation, written in Python/Twisted). The README describes it plainly: “a scalable, low-cost, enterprise-ready, community-driven alternative, fully implementing the Matrix Specification for all but the most niche uses.” [README]

The project is the official successor to conduwuit, which was itself a community fork of Conduit (the original Rust-based Matrix homeserver). According to the README, Tuwunel is now used by companies with full-time staff dedicated to its development, and is “primarily sponsored by the government of Switzerland where it is currently deployed for citizens.” [README] That’s a materially different credibility signal than most self-hosted projects at 1,736 GitHub stars.

The freeyourtech.org collective — which deploys privacy-first services for their member community — runs Tuwunel as their Matrix server backend and recommends FluffyChat as the client [2]. It’s that kind of deployment: small privacy-focused organizations that want a leaner stack than what Element’s hosted offering or a full Synapse install demands.

---

Why people choose it over Synapse, Dendrite, and Discord

The third-party coverage of Tuwunel specifically is thin — it appears on the awesome-selfhosted list [1], gets deployed by privacy collectives [2], and shows up in tool directories [3], but no dedicated benchmarks or head-to-head reviews exist yet. What does exist is a clear pattern of why people choose any lightweight Rust homeserver over the alternatives.

Versus Synapse. Synapse is the Matrix reference implementation and the most feature-complete server available. It also requires significantly more RAM and CPU than Tuwunel, making it impractical on a $5 VPS. Multiple self-hosting communities have documented Synapse consuming 1–2GB RAM at idle even for small deployments. Tuwunel’s Rust implementation targets the opposite end of the resource curve. For a small team or community that doesn’t need Synapse’s full feature surface (some niche federation behaviors, Mjolnir admin bot compatibility at scale), Tuwunel is the choice that doesn’t require a dedicated server.

Versus Dendrite. Dendrite is Matrix’s second reference implementation, also targeting performance, written in Go. It has been in active development longer than Tuwunel and has more documented deployments. Tuwunel’s advantage is its conduwuit lineage — it inherits a database format and configuration model that a significant number of self-hosters already know. The migration path from conduwuit to Tuwunel is described as a “binary swap” — change the executable path, everything else continues working [README]. No equivalent exists for moving from conduwuit to Dendrite without data export/import.

Versus Discord. Discord is the default for communities in 2026 — free, polished, voice channels that actually work, and a mobile app that doesn’t need configuration. The argument against Discord for privacy-conscious users and organizations is straightforward: Discord has access to everything sent through it, including private messages, and its business model is advertising and data. The matrix.org homeserver saw a significant spike in registrations when Discord announced mandatory age verification requirements for all users [4] — the decentralized alternative to centralized platforms becomes immediately relevant when a platform’s policies shift. Tuwunel (or any Matrix homeserver) lets you run that alternative on hardware you control, with no corporate policy changes affecting your community.

Versus Slack/Teams. Slack Pro and Microsoft Teams charge per user per month. For a team of any meaningful size, that’s a recurring bill that scales with headcount. Tuwunel on a $10 VPS serves the same function — team channels, file sharing, integrations via Matrix bridges — at a fixed infrastructure cost regardless of how many users you add.

---

Features

Based on the README, documentation, and what the Matrix specification requires any conforming homeserver to implement:

Core Matrix features:

• Full Matrix Specification implementation “for all but the most niche uses” [README]
• End-to-end encrypted messaging (via clients like Element, FluffyChat, Cinny)
• Rooms, spaces, and direct messages
• Federation with the global Matrix network — your users can talk to users on matrix.org or any other federated homeserver
• Guest access, registration tokens for invite-only signup [README][2]
• Bridges to external platforms (Discord, Slack, Telegram) via the standard Matrix bridge ecosystem

Deployment and operations:

• Docker images on both DockerHub and GitHub Container Registry [README]
• Static binaries, Deb and RPM packages, Arch AUR packages, NixOS module [README]
• Alpine Linux package [README]
• TOML-based configuration (copy the example, edit two fields, run) [README]
• Caddy reverse proxy support with documented configuration [README]
• Optional TLS termination at the server level, without a reverse proxy [README]
• Root domain delegation via .well-known [README]

Migration:

• Migration from conduwuit: supported, described as a binary swap [README]
• Migration from Synapse: planned, tracked in issue #2, not yet implemented [README]
• Migration from Conduit (original): planned for near future, tracked in issue #41 [README]
• Migration from other Conduit forks: explicitly unsupported and dangerous — different forks share a database version format without awareness of each other, and switching between them corrupts the database permanently [README]

Client compatibility:

• Works with any Matrix-spec-compliant client: Element, FluffyChat, Cinny, Nheko, and others [README]
• Works with any standard Matrix bridge or bot [README]

What’s missing or unclear:

• No native admin UI — management is via the Matrix admin API or a separate tool
• No mention of push notification relay support in the documentation reviewed
• Synapse’s “admin rooms” feature and some of the more advanced Mjolnir moderation tooling may have limited support — specific compatibility data not available in sources reviewed

---

Pricing: SaaS vs self-hosted math

Tuwunel itself is free software (Apache-2.0) [README]. There is no hosted SaaS version of Tuwunel — you self-host it or you don’t use it. The pricing question is therefore: what does self-hosting cost, and what are you replacing?

Self-hosting Tuwunel:

• Software license: $0 [README]
• VPS: $5–10/mo handles small communities on Hetzner or Contabo; 1–2 GB RAM is the realistic minimum
• Domain name: ~$10–15/year
• Your time to set up and maintain

What you’re replacing:

Discord: Technically free, but the cost is data. Discord reads message content for “safety” enforcement, serves ads, and has repeatedly changed policies in ways that disrupted communities (the age verification announcement being the latest example [4]). The migration traffic that hit matrix.org in 2025 was a direct result of Discord policy changes [4] — that’s the recurring non-monetary cost of building your community on a platform you don’t control.

Slack Pro: Approximately $7–8/user/month at current pricing (data not in sources reviewed — check current Slack pricing). A team of 15 people runs $105–120/month. Tuwunel on a $10 VPS handles the same function for $10/month, regardless of team size. Over a year, that’s roughly $1,300–1,400 saved — before accounting for growth.

Microsoft Teams: Bundled into Microsoft 365 Business Basic at approximately $6/user/month. Similar math applies for any team not already in the Microsoft stack.

The honest caveat: these per-user SaaS prices have a floor. Tuwunel’s operational cost has a floor too — the learning curve to set it up, and the occasional hour to maintain it. If your team already pays for Microsoft 365 for other reasons, Teams is effectively free, and the break-even math disappears.

---

Deployment reality check

The Tuwunel README is refreshingly direct about deployment. The core steps are: configure a TOML file, set up TLS (Caddy handles this automatically), start the server, register as admin [README].

What you actually need:

• A Linux VPS with 1–2 GB RAM minimum (more if you’re running a large community or enabling features like media storage)
• Docker, or the ability to run a binary
• A domain name at the root level — the README specifically warns against using a subdomain for server_name because you can never change it later, though you can delegate via .well-known [README]
• A reverse proxy (Caddy recommended; nginx works) if you want automatic TLS certificate handling

What the setup actually looks like: The documented path is: copy tuwunel-example.toml, set server_name and database_path, run the binary or container. Caddy handles HTTPS without additional certificate management. First user to register gets admin. For a conduwuit user, it’s genuinely a binary swap [README].

What can go sideways:

The Synapse migration is the big one for anyone coming from an existing deployment. It’s explicitly not supported yet [README]. If you’re running Synapse and want to move to something lighter, Tuwunel is not your path today. Watch issue #2 on the GitHub repo.

The database corruption warning is serious and worth repeating: if you’ve ever run any other Conduit-lineage fork (not conduwuit specifically, but any of the various forks), do not attempt to run Tuwunel on that data. The README is blunt about this: “The database will permanently corrupt and we will not be able to help you.” [README] Check your lineage before swapping binaries.

freeyourtech.org deploys Tuwunel with a registration token to prevent spam [2]. If you’re running an open registration server, abuse prevention requires additional tooling — the token approach is the documented simple solution, but it’s manual.

Federation is automatic but brings federation-level complexity: moderating content from federated servers, handling spam from other homeservers, and the general challenge of being part of a decentralized network where bad actors exist. This is a Matrix-level concern, not Tuwunel-specific.

Realistic time estimate for a technical user: 1–2 hours to a working instance on a fresh VPS, including domain and TLS setup. For a non-technical founder, this requires a technical helper or a one-time deployment service — the configuration is simple, but debugging DNS delegation and TLS issues requires comfort with Linux servers.

---

Pros and Cons

Pros

• Apache-2.0 license. Clean, commercially permissive. No “fair-code” restrictions, no commercial licensing tiers, no strings [README].
• Rust performance. The language choice is the point — significantly lower RAM and CPU than Synapse, making a $5–10 VPS viable where Synapse requires more resources. This is the primary reason the project exists.
• Swiss government credibility signal. Active deployment for a national government means Tuwunel has real production workloads behind it, not just hobbyist test instances [README].
• Multiple deployment paths. Docker, static binaries, Deb/RPM, Arch, Nix, Alpine — whatever your infrastructure preference, a package exists [README].
• Simple conduwuit migration. Binary swap, no data migration needed — existing conduwuit deployments can move over without disruption [README].
• Active development. Full-time staff with commercial backing, not a side project that goes dark when the maintainer gets busy [README].
• Real-world production use. freeyourtech.org deploys it for their member community [2]; it appears across self-hosting recommendation lists [1][3].

Cons

• No Synapse migration path yet. This is the most significant limitation for anyone wanting to move an existing Matrix deployment. It’s planned but not done [README].
• Limited third-party reviews. There is essentially no independent performance benchmarking or comparative analysis published for Tuwunel as of this review. You’re relying on the project’s own claims about its resource efficiency.
• Young project. 1,736 GitHub stars and conduwuit lineage means the community is smaller than Synapse’s or even Dendrite’s. Edge cases in the Matrix spec may surface issues that larger deployments would catch faster.
• No native admin UI. Server administration requires the API or third-party tools. Acceptable for technical operators; not suitable for non-technical founders managing their own instance.
• Federation complexity inherited. Any Matrix homeserver inherits the challenge of federation-level abuse, spam from other servers, and the operational overhead of participating in a decentralized network. Tuwunel doesn’t add this complexity, but it doesn’t solve it either.
• Conduit fork fragmentation warning. The database corruption risk when switching between Conduit-lineage forks is a genuine hazard. Users with unclear server history need to verify carefully before migrating [README].

---

Who should use this / who shouldn’t

Use Tuwunel if:

• You’re migrating off Discord or want an alternative that isn’t subject to a single company’s policy changes.
• You’re already running conduwuit and want to upgrade to the actively-maintained successor.
• You’re running a privacy-focused community or organization that needs team communication under your own infrastructure.
• You want a Matrix homeserver that fits on a small VPS — Synapse’s resource requirements are a blocker for you.
• You’re comfortable with Docker or Linux administration, or have someone technical who can handle initial setup.

Wait on it if:

• You’re running Synapse and want to migrate — wait for issue #2 to be resolved [README].
• You need the full Synapse feature surface, including specialized admin tooling (Mjolnir at scale, Draupnir, full server admin API parity).
• You’re a non-technical founder who needs to self-manage the deployment — the setup is straightforward by self-hosting standards, but it’s not point-and-click.

Skip it entirely if:

• Your team is comfortable on Discord and the privacy tradeoff is acceptable. Tuwunel’s value is control and privacy; if those don’t matter to your use case, the setup overhead isn’t worth it.
• Your organization is already paying for Microsoft 365 — Teams is included and solving the same problem.
• You need an enterprise-grade deployment with professional support SLAs and aren’t willing to engage the project’s community for help.

---

Alternatives worth considering

• Synapse — the Matrix reference implementation. More features, more documentation, more community resources, significantly higher resource requirements. The right choice for large deployments where resource cost is secondary to compatibility breadth.
• Dendrite — the Matrix team’s Go-based second reference implementation. Further along in development than Tuwunel for new deployments, no conduwuit migration path, different trade-offs.
• Conduit — the original Rust homeserver Tuwunel descends from. In maintenance mode relative to Tuwunel; no active development team. Only consider if you’re specifically locked to its feature set.
• Element’s managed hosting — if you want Matrix without running your own server. Commercial product from the main Matrix development team. You give up self-hosting but gain managed infrastructure and support.
• Mattermost — if you specifically want a Slack replacement rather than a federated protocol. Self-hosted, Apache-2.0 community edition, purpose-built for team messaging rather than the broader Matrix protocol surface.
• Rocket.Chat — similar positioning to Mattermost. More features in the community edition, heavier resource footprint. Worth comparing if your use case is internal team messaging rather than federated community hosting.

The realistic decision for most self-hosters is Tuwunel vs Synapse if you’re committed to Matrix, or Tuwunel vs Mattermost if you want self-hosted team messaging without the Matrix federation layer. Tuwunel wins on resource efficiency; Synapse wins on maturity; Mattermost wins on non-technical operator usability.

---

Bottom line

Tuwunel is the answer to a specific problem: you want a Matrix homeserver, you don’t have the RAM budget for Synapse, and you want a project that has real production deployments and active full-time development behind it. The Swiss government sponsorship and company backing distinguish it from the typical hobbyist-maintained Synapse alternative — this is not a project you’re betting on surviving on the maintainer’s goodwill. The Apache-2.0 license, multi-platform packaging, and dead-simple conduwuit upgrade path make it the obvious choice for the self-hosting community that conduwuit served. Its limitations are real: no Synapse migration yet, limited third-party validation, and the inherent complexity of the Matrix ecosystem. But for privacy-focused teams escaping Discord’s policy volatility [4], or communities paying per-user SaaS bills that scale with headcount, a $10 VPS running Tuwunel is a straightforward and legitimate alternative.

---

Sources

1. Clones/awesome-selfhosted — git.libox.fr — Mirror of the awesome-selfhosted list; Tuwunel appears in the Communication — Custom Communication Systems category. https://git.libox.fr/Clones/awesome-selfhosted
2. Free Your Tech! — Our Services — freeyourtech.org; documents their production deployment of Tuwunel as their Matrix homeserver backend for member community communication. https://freeyourtech.org/services/
3. Easy Indie App — Glance — easyindie.app; tool directory listing Matrix and self-hosted communication options including Tuwunel. https://easyindie.app/glance
4. Matrix.org — General Blog — matrix.org; context on the Discord age-verification-driven migration wave to Matrix and Matrix’s ecosystem status. https://matrix.org/category/general/

Primary sources:

• GitHub repository and README: https://github.com/matrix-construct/tuwunel (1,736 stars, Apache-2.0 license)
• Official documentation and homepage: https://matrix-construct.github.io/tuwunel/
• Demo server: https://try.tuwunel.chat
• DockerHub: https://hub.docker.com/r/jevolk/tuwunel