Conduit vs Synapse: Matrix Homeservers Compared

Quick Verdict

Want a Matrix homeserver without dedicating gigabytes of RAM to it? Conduit runs a fully functional homeserver in 70-200 MB of memory — a fraction of Synapse’s 1-2 GB baseline. The trade-off: Conduit is beta software that doesn’t implement the full Matrix spec. For personal use and small groups, Conduit is excellent. For anything production-grade or federation-heavy, Synapse remains the only complete option.

Updated March 2026: Verified with latest Docker images and configurations.

Overview

Both Conduit and Synapse are Matrix homeservers — they implement the Matrix protocol for decentralized, encrypted messaging. Clients like Element, FluffyChat, and SchildiChat connect to either server identically. The difference is in implementation philosophy and maturity.

Synapse is the reference Matrix homeserver, written in Python by the Matrix.org Foundation. It implements the complete Matrix specification including all room versions, push notifications, application services (bridges), and server-side search. Every Matrix feature was first built and tested against Synapse. The downside: Python’s memory footprint means Synapse consumes 1-2 GB RAM even idle.

Conduit is a community-developed Matrix homeserver written in Rust. It uses an embedded RocksDB database instead of requiring PostgreSQL, and its compiled Rust binary eliminates Python’s runtime overhead. A single Docker container handles everything. The project is in beta (v0.10.x) and doesn’t implement every Matrix feature — but for basic messaging, calls, and federation, it works.

Feature Comparison

Feature	Conduit v0.10.12	Synapse v1.147.1
Matrix spec compliance	Partial (beta, v0.10.x)	Full (reference implementation)
E2E encryption	Yes	Yes
Federation	Yes (configurable)	Yes (full support)
Voice/video calls	Yes (via TURN)	Yes (via TURN)
Push notifications	Basic	Full (Firebase, APNs, Sygnal)
Application services / bridges	Limited	Full (IRC, Telegram, Signal, WhatsApp, etc.)
Server-side search	Basic	Full (with full-text indexing)
Spaces (room groups)	Partial	Full
Room versions	Up to v10	All versions (v1-v11)
Threads	Basic	Full
SSO / OIDC	No	Yes (SAML, CAS, OIDC)
Admin API	Basic	Comprehensive
Worker mode (horizontal scaling)	No	Yes (split across multiple processes)
Database	RocksDB embedded (or SQLite)	PostgreSQL required (production)
Backend language	Rust	Python 3
Docker containers	1	2 (Synapse + PostgreSQL)
License	Apache-2.0	AGPL-3.0

Installation Complexity

Conduit deploys as a single container with no external dependencies. All configuration happens through environment variables:

services:
  conduit:
    image: matrixconduit/matrix-conduit:v0.10.12
    environment:
      CONDUIT_SERVER_NAME: "matrix.example.com"
      CONDUIT_DATABASE_BACKEND: "rocksdb"
      CONDUIT_DATABASE_PATH: "/var/lib/matrix-conduit/"
      CONDUIT_PORT: "6167"
      CONDUIT_ADDRESS: "0.0.0.0"
      CONDUIT_MAX_REQUEST_SIZE: "20000000"  # 20 MB
      CONDUIT_ALLOW_REGISTRATION: "false"
      CONDUIT_ALLOW_FEDERATION: "true"
      CONDUIT_ALLOW_ENCRYPTION: "true"
      CONDUIT_TRUSTED_SERVERS: '["matrix.org"]'
      CONDUIT_MAX_CONCURRENT_REQUESTS: "100"
      CONDUIT_DB_CACHE_CAPACITY_MB: "300"
      CONDUIT_LOG: "warn"
    volumes:
      - conduit_data:/var/lib/matrix-conduit/
    ports:
      - "6167:6167"
    restart: unless-stopped

volumes:
  conduit_data:

Set CONDUIT_SERVER_NAME, run docker compose up -d, configure your reverse proxy and .well-known delegation, and you have a working homeserver. Total setup: 5-10 minutes.

Important: CONDUIT_SERVER_NAME cannot be changed after first run — it’s baked into the database. CONDUIT_ADDRESS must be 0.0.0.0 in Docker (defaults to 127.0.0.1, which would make the server unreachable from outside the container).

Synapse requires PostgreSQL, a YAML configuration file, and secret generation:

services:
  synapse:
    image: matrixdotorg/synapse:v1.149.1
    volumes:
      - ./synapse-data:/data
    depends_on:
      postgres:
        condition: service_healthy
    ports:
      - "8008:8008"
    restart: unless-stopped

  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: synapse
      POSTGRES_USER: synapse
      POSTGRES_PASSWORD: CHANGE_ME_STRONG_PASSWORD
      POSTGRES_INITDB_ARGS: "--encoding=UTF8 --locale=C"
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U synapse"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped

volumes:
  pgdata:

Before starting, generate the config:

docker run --rm \
  -v ./synapse-data:/data \
  -e SYNAPSE_SERVER_NAME=example.com \
  -e SYNAPSE_REPORT_STATS=no \
  matrixdotorg/synapse:v1.149.1 generate

Then edit synapse-data/homeserver.yaml to configure PostgreSQL (replacing the default SQLite), set registration_shared_secret, macaroon_secret_key, and form_secret (each generated with openssl rand -hex 32). The database section needs:

database:
  name: psycopg2
  args:
    user: synapse
    password: CHANGE_ME_STRONG_PASSWORD
    database: synapse
    host: postgres
    cp_min: 5
    cp_max: 10

You also need .well-known/matrix/server and .well-known/matrix/client JSON files served from your domain, plus a reverse proxy with TLS. Create users via CLI: docker compose exec synapse register_new_matrix_user -c /data/homeserver.yaml. Setup time: 20-40 minutes.

Performance and Resource Usage

Resource	Conduit v0.10.12	Synapse v1.147.1
RAM (idle, no users)	70-100 MB	800 MB - 1 GB
RAM (1-5 users)	100-200 MB	1-1.5 GB
RAM (10-50 users)	200-500 MB	2-4 GB
RAM (100+ users)	500 MB - 1 GB	4-8 GB (with workers)
CPU (small instance)	Minimal (<1% idle)	Low-medium
Disk growth	~500 MB/week active	~1 GB per 100K messages + media
Database	Embedded (no separate service)	PostgreSQL (separate container)
Horizontal scaling	Not supported	Worker mode (split federation, media, sync)

The performance gap is dramatic. Conduit uses 5-10x less RAM than Synapse for equivalent user counts. On a Raspberry Pi 4 with 4 GB RAM, Conduit leaves room for other services while Synapse would consume most available memory.

However, Synapse’s worker mode enables horizontal scaling for large deployments — splitting federation, media handling, and client sync across multiple processes. Conduit has no equivalent; performance is limited to what a single process can handle.

Community and Support

Synapse is developed by the Matrix.org Foundation with full-time engineers and corporate sponsors (Element). It has 12,000+ GitHub stars, comprehensive documentation at matrix-org.github.io/synapse, and a large operator community. Every Matrix feature is tested against Synapse first. Breaking changes are rare and well-documented.

Conduit has 2,200+ GitHub stars and an active Matrix room for community support. Documentation is sparser — the README and a few wiki pages cover basics, but advanced configuration often requires reading source code or asking in the Matrix room. Note that Conduit’s ecosystem is evolving: conduwuit (a performance fork) and Tuwunel (Swiss government-sponsored successor) share the same data format, so migration between forks is possible.

Use Cases

Choose Conduit If…

• You’re running a personal or small-group homeserver (under 50 users)
• RAM is constrained (Raspberry Pi, small VPS, shared server)
• You want the simplest possible Matrix setup (one container, no PostgreSQL)
• You don’t need bridges to other platforms (IRC, Telegram, Signal)
• You’re comfortable with beta software and occasional missing features
• You want to experiment with Matrix without committing significant resources

Choose Synapse If…

• You need full Matrix spec compliance (all room versions, all features)
• You use or plan to use bridges (mautrix-telegram, mautrix-signal, matrix-appservice-irc)
• SSO/OIDC integration is required
• Your deployment will serve 50+ users
• You need horizontal scaling via worker mode
• Production reliability and comprehensive documentation matter

Final Verdict

For personal Matrix hosting — messaging friends, family, or a small team — Conduit delivers 90% of the experience at 10% of the resource cost. Its single-container deployment and embedded database make it the easiest Matrix server to run.

For anything beyond personal use, Synapse is the only production-grade option. Bridges, SSO, full spec compliance, worker scaling, and comprehensive admin APIs all require Synapse. The resource cost is real but justified for the feature set.

The practical recommendation: start with Conduit if you’re exploring Matrix. Migrate to Synapse when you hit Conduit’s limitations — you’ll know when you need bridges or when spec gaps cause client compatibility issues.

FAQ

Can Conduit and Synapse homeservers federate with each other?

Yes. Both implement the Matrix federation protocol. Users on a Conduit homeserver can join rooms on Synapse homeservers and vice versa. The federation layer is protocol-defined, not implementation-specific.

Can I migrate from Conduit to Synapse later?

No direct migration tool exists. You would need to create new accounts on Synapse and rejoin rooms. Message history in federated rooms would be available (the room state is distributed), but DMs and local room history would not transfer. Plan your choice carefully if you have significant local data.

Does Conduit support Element Web as a client?

Yes. Element Web, Element Desktop, Element mobile, FluffyChat, SchildiChat, and other Matrix clients work with Conduit. Some advanced features (threads, spaces) may have partial support depending on the client and Conduit’s current spec coverage.

Why does Synapse use so much RAM?

Synapse is written in Python with Twisted (async networking framework). Python’s memory overhead for objects, combined with caching of room state and user presence data, creates a high baseline. The Matrix.org team has worked on reducing this, but Python’s runtime characteristics set a floor. Worker mode helps by distributing load across processes.

What is conduwuit / Tuwunel?

conduwuit is a performance-focused fork of Conduit. Tuwunel is its official successor, sponsored by the Swiss government. Both share Conduit’s data format and can use the same database. If Conduit’s development slows, these forks provide a migration path without data loss.

Related

• How to Self-Host Conduit
• Best Self-Hosted Communication & Chat
• Self-Hosted Alternatives to Discord
• Docker Compose Basics
• Reverse Proxy Setup
• Fediverse and ActivityPub Explained