[$ xmrhost] _

$ diff /etc/matrix/{synapse,dendrite,conduit}

[$ ] Synapse vs Dendrite vs Conduit — Matrix homeserver implementations

// TLDR

Synapse is the reference implementation in Python — feature-complete, memory-hungry, production-mature. Dendrite is the second-generation Go implementation by Element — feature-complete as of 2024, lower memory footprint, microservice-shaped, production-ready for small-to-medium deployments. Conduit is the third-party Rust implementation — lean, single-binary, the right choice for a personal homeserver where federation breadth is acceptable to trade against minimal resource footprint. For a Tor-hidden-service Matrix homeserver on a tor-2 plan, Conduit is the default and Synapse the fallback if specific feature requirements demand it.

// AT A GLANCE

$ compare --short

// dimension // synapse // dendrite // conduit
language Python 3.9+ Go Rust
maintainer Element Element Timo Kösters + community
license AGPLv3 Apache 2.0 Apache 2.0
first stable release 2017 (v0.18.0) 2022 (v0.8.0) 2021 (v0.1.0)
backing database Postgres (SQLite for tiny) Postgres / SQLite RocksDB (embedded)
memory footprint (10 users, idle) ~800 MB ~250 MB ~50 MB
memory footprint (100 users, active) ~2-4 GB ~800 MB ~250 MB
federation coverage complete complete (as of 2024) complete (as of 2024)
E2EE (client-side keys) full full full
room version coverage v1 through v11 v1 through v11 v1 through v11
deployment shape workers / monolith monolith / microservice single binary
XMRHost-recommended plan tor-4 ($85/mo) or vps-4 tor-2 ($42/mo) or vps-2 tor-1 ($20/mo) or vps-1

// SYNAPSE — REFERENCE

$ man synapse

Synapse is Element's reference Matrix homeserver, written in Python. It is the implementation the Matrix spec is tested against; new spec features land in Synapse first and Dendrite / Conduit follow. For a deployment that needs guaranteed compatibility with the leading edge of the spec (custom auth, novel room versions, room-server-administration plugins) Synapse is the only choice.

Trade-offs:

  • Memory footprint is the dominant cost. Python's object overhead + Synapse's state-replication design hold most of the working room set in RAM. A 100-user active homeserver comfortably wants 4 GB; a federation-active 500-user server wants 8 GB.
  • Postgres backend mandatory at any scale. SQLite is allowed but breaks on any non-trivial deployment. Plan for Postgres tuning (work_mem, shared_buffers, autovacuum schedule).
  • Workers for scale. Synapse's worker model splits the homeserver into specialised processes (federation_sender, generic_worker, media_repository, etc.). Necessary above ~200 users; doubles the operational complexity.
  • AGPLv3 license. Most operators don't care; if you intend to fork-and-host-as-a-service with closed-source modifications, read the licence.

// DENDRITE — SECOND-GEN

$ man dendrite

Dendrite is Element's Go rewrite of the homeserver, designed to address Synapse's resource profile and operational complexity. After a long beta, Dendrite reached production-readiness in 2022- 2024 and is now the recommended choice for new deployments where Synapse's resource cost is prohibitive but Synapse's exact feature coverage is not strictly required.

Trade-offs:

  • Microservice-shaped. Dendrite's component architecture (federation_api, client_api, room_server, sync_api, etc.) can run as separate processes or as one binary (monolith mode). Monolith is the recommended default for deployments below ~500 users; microservice mode is for scale.
  • Feature parity but not feature-leading. Dendrite implements the same Matrix spec as Synapse but new features land in Synapse first. If your deployment depends on recently-spec'd features check Dendrite's roadmap before choosing.
  • SQLite viable for personal-scale. Unlike Synapse, Dendrite's SQLite backend is honest production-grade for 1-20-user homeservers. Postgres for anything larger.
  • Apache 2.0 license. No copyleft considerations.

// CONDUIT — LEAN

$ man conduit

Conduit is the third-party Matrix homeserver in Rust, started by Timo Kösters in 2020. The design centre is "everything fits in one binary" — Conduit ships as a single executable with an embedded RocksDB database, no Postgres dependency, no worker processes, no external state. For a personal homeserver running on a tor-1 ($20/mo, 2 GB RAM) plan, Conduit is the only one of the three that comfortably fits.

Trade-offs:

  • Smaller community. Maintained by a smaller team than Synapse / Dendrite. Issue-response time and feature coverage track that. For a personal homeserver this is acceptable; for a 500-user deployment it is not.
  • RocksDB embedded. No separate database process. Backups are a file-copy of the data directory while Conduit is stopped, or a RocksDB-aware snapshot tool.
  • Federation maturity. Federation works against all the major implementations (matrix.org, Element, Beeper, the fediverse Matrix bridges) as of 2024 milestones. Edge cases — obscure room versions, unusual federation graphs — may surface regressions Synapse would silently tolerate.
  • Single-server scale ceiling. Designed for single-process operation; horizontal scale is not the feature. If you reach 200+ active users on a Conduit homeserver, plan to migrate to Dendrite.

// HOW TO CHOOSE

$ man choose-homeserver

  • Solo / 1-10 users / Tor-hidden-service homeserver: Conduit. Fits on a tor-1 ($20/mo). Single binary, embedded database, lowest operational surface.
  • Small community / 10-100 users: Dendrite. Fits on a tor-2 or vps-2 ($42/mo). Postgres or SQLite. Mature enough for federation-heavy use.
  • Larger community / 100-500+ users / federation-leading-edge: Synapse with Postgres + workers. Plan for tor-4 ($85/mo) or vps-4+; budget for 8-16 GB RAM if growth is expected.
  • Spec-leading-edge / room-administration plugins: Synapse — the reference implementation is the canonical fit.

// SEE ALSO

$ ls /usr/share/doc/xmrhost/matrix