For most small groups leaving Slack or Discord, Tuwunel is the better starting point. It is one Rust binary with an embedded RocksDB database, so you run one container, not a homeserver plus PostgreSQL plus Redis and workers. Synapse is still the safer choice once you need enterprise single sign-on, a mature admin API or room to grow past a few hundred active users. The hardware gap between the two is real, but voice and video calls, media storage and joining large federated rooms affect your bill more than the server you pick.

TL;DR: which Matrix server fits you

  • A family or friend group of 5 to 15 moving off Discord: run Tuwunel, because one container on a mini PC or a small VPS is enough and there is no database to look after.
  • A homelabber with a Raspberry Pi 5 or an N100 box: run Tuwunel, because its RAM use stays low enough to sit beside other services on the same machine.
  • A 20 to 60 person open source community leaving Slack: start with Tuwunel unless you depend on bots or admin tools that only target Synapse's admin API.
  • A 150+ person company with an identity provider and compliance rules: run Synapse with PostgreSQL, because SSO integrations, workers and admin tooling are mature and widely documented.
  • Anyone planning to join huge public federated rooms: size the hardware for federation load first, whichever server you choose, because large room state hits both of them hard.
  • A team that already runs Synapse happily: stay put, because there is no supported in-place migration between the two and your server name is permanent.

The central tradeoff is simple: Tuwunel saves hardware and admin time today, while Synapse gives you more growing room and a larger ecosystem in exchange for more moving parts.

Table of contents

  • What are Tuwunel and Synapse, and why does the choice matter when you leave Slack?
  • How much RAM does each Matrix server use at idle and under load?
  • Where does the CPU time go: federation, state resolution and media
  • RocksDB vs PostgreSQL: what the database choice costs in disk and maintenance
  • How fast does disk usage grow per month for a small team?
  • Can Tuwunel handle 200 users, or do you need Synapse workers?
  • What hardware do you need for 10, 50 and 200 users?
  • Running each server in Docker: containers, compose files and moving parts
  • Voice and video calls: the TURN and LiveKit cost neither server removes
  • What do Slack and Discord users give up, and what do they gain?
  • How much does it really cost over 3 years compared to a subscription?
  • Backups, upgrades and recovery: how much admin time each server takes
  • Data sovereignty: where your messages live after you leave Slack
  • Which Matrix server should you choose for your group?

What are Tuwunel and Synapse, and why does the choice matter when you leave Slack?

Both are Matrix homeservers. A homeserver stores your group's messages, rooms and accounts, and talks to other Matrix servers over federation. Your users never see it directly. They connect with a client such as Element, the same way they used the Slack or Discord app before. The homeserver is the part you run, pay for and maintain, so it decides how much hardware and admin time the move will cost.

  • Synapse: the reference Matrix homeserver, developed by Element and released under AGPL-3.0. It is written mainly in Python, with Rust for some hot paths. It expects a PostgreSQL database in production, since SQLite is only meant for testing, and it scales out by splitting work across worker processes coordinated through Redis.
  • Tuwunel: a Matrix homeserver written in Rust and released under Apache-2.0. It carries on the conduwuit project, itself a fork of Conduit. It ships as one binary with an embedded RocksDB database, so there is no separate database server to run.
  • Why the choice is hard to reverse: your server name, the part after the colon in @alice:example.com, is permanent once rooms federate. There is no supported tool to move a live server between Synapse and Tuwunel, so the server you start on is usually the one you keep.
  • Why it matters for cost: the language runtime, the database and the process model drive idle RAM, disk growth and the number of containers you look after. That gap counts most on small hardware, where a Slack or Discord refugee usually starts.

How much RAM does each Matrix server use at idle and under load?

No published benchmark fits your group, so treat any single number online with suspicion. What you can predict is the shape of the memory curve, and the knobs that control it. The surest check is to run docker stats for a week on your own traffic before you size anything.

Factor Tuwunel Synapse
Processes to count One container: the server and its embedded RocksDB share one memory footprint At least two: the Python homeserver plus PostgreSQL, and more once you add workers and Redis
Idle baseline Low, since there is no interpreter and no separate database server Higher, since the Python runtime and PostgreSQL's shared_buffers both reserve memory before anyone logs in
Main tuning knob cache_capacity_modifier and the RocksDB cache settings in tuwunel.toml caches.global_factor in homeserver.yaml, or the SYNAPSE_CACHE_FACTOR environment variable
What causes spikes Joining large federated rooms, when room state is fetched and resolved The same federation joins, plus garbage collection pauses and cache growth in long-running workers
Behaviour on 2 to 4 GB hosts Usually leaves room for other containers beside it Workable for a small group, but PostgreSQL and Synapse compete for the same headroom

The practical point is that both servers fill their caches over time. Rising RSS after a few days is normal for both and does not mean a leak. Cap the caches before you cap the container, or the out-of-memory killer will choose for you.

Where you run it changes how much headroom matters: a self-managed VPS, a home server, a NAS or Yundera. Yundera is a managed Personal Cloud Server, built on CasaOS, that runs self-hosted apps as Docker containers on a server dedicated to the user. On any shared box, the homeserver's peak, not its idle figure, decides what else fits.

Where does the CPU time go: federation, state resolution and media

A Matrix server is idle most of the day and busy in short bursts. Knowing what causes those bursts tells you which settings to change before you buy a bigger CPU.

  • State resolution on room joins: when a user joins a large federated room such as #matrix:matrix.org, your server fetches and checks the room's full state history. This is the heaviest single job either server does, and it can max out a core for minutes on small hardware. Private rooms on your own server barely register.
  • Federation traffic: every remote server in a shared room sends events your server must verify and sign. Synapse runs this through Python, held back by the global interpreter lock, which is why large deployments split it into federation_sender and federation_reader workers. Tuwunel runs on a multi-threaded async runtime, so one process can use several cores without extra workers.
  • Presence: online and typing indicators create constant small updates to every room member. Synapse lets you set presence: enabled: false in homeserver.yaml. Tuwunel has equivalent presence switches in tuwunel.toml. Turning presence off is the cheapest CPU saving on either server.
  • Media thumbnails and URL previews: thumbnailing images and fetching link previews are bursty CPU and network jobs. Synapse keeps URL previews off unless url_preview_enabled is set, and both servers let you limit upload sizes.
  • Client sync: many open clients polling for new messages adds steady load, mostly as users grow from tens to hundreds.

On a VPS, a home server, a NAS or Yundera alike, the trigger to watch is the same: one user joining one huge public room, not your own group chatting.

RocksDB vs PostgreSQL: what the database choice costs in disk and maintenance

The database is where the two servers differ most in daily upkeep. Tuwunel embeds RocksDB inside its own process. Synapse hands storage to a separate PostgreSQL server. Each brings its own disk behaviour and its own chores.

  • RocksDB write pattern: RocksDB is a log-structured store. It writes new data to fresh files and merges them later in a background step called compaction. Compaction needs temporary free space and steady disk I/O, so a nearly full volume or a slow SD card causes stalls before it causes errors. Keep generous free space on the volume that holds database_path from tuwunel.toml.
  • RocksDB upkeep: there is no separate service to tune, upgrade or vacuum. Compaction runs on its own. The cost is that the data files only make sense to Tuwunel, so you cannot query them with standard tools when something looks wrong.
  • PostgreSQL setup rules: Synapse needs its database created with LC_COLLATE='C' and LC_CTYPE='C'. A database made with the wrong locale is a common first-install mistake, and fixing it later means a dump and restore.
  • PostgreSQL bloat: Synapse's state_groups_state table is known to grow far faster than message volume suggests. The synapse_auto_compressor tool from the rust-synapse-compress-state project exists to shrink it, and autovacuum must keep up with dead rows.
  • PostgreSQL major upgrades: moving from one major release to another, for example 15 to 16, needs pg_upgrade or a full pg_dump and restore. That adds a planned upgrade task Tuwunel does not have.
  • Tooling advantage: PostgreSQL works with psql, standard monitoring and decades of documentation, which helps a lot when you need to look inside the data.

How fast does disk usage grow per month for a small team?

Text messages are almost free. A year of chat for a small group takes little space next to a few weeks of shared photos and screen recordings. Your monthly growth rate comes from a handful of drivers you can measure and control.

  • Uploaded media: images, videos and files your users send are the largest driver by far. Synapse's max_upload_size in homeserver.yaml defaults to 50M. Tuwunel has its own request size limit in tuwunel.toml. Setting a lower cap is the bluntest and most effective way to slow growth.
  • Remote media cache: when users sit in federated rooms, your server downloads and keeps copies of media posted by other servers. One busy public room can outgrow your own group's uploads. Synapse can expire it with media_retention and its remote_media_lifetime option.
  • Federated room state: joining large public rooms stores their state and history on your disk. On Synapse this lands in PostgreSQL and inflates state_groups_state. On Tuwunel it lands in RocksDB. Either way, it does not shrink just because your users leave the room.
  • Thumbnails: each uploaded image produces several resized copies. They are small one by one but add up with heavy photo sharing.
  • Measuring it yourself: run du -sh on the media and database volumes each week, and on Synapse also query SELECT pg_size_pretty(pg_database_size('synapse'));. Four weekly readings give you a growth line you can trust more than any published estimate.

For a private group that stays off large public rooms, plan disk around media habits. For a group that federates widely, plan around the rooms it joins.

Can Tuwunel handle 200 users, or do you need Synapse workers?

"200 users" hides the real question. Two hundred registered accounts, most of them reading a few rooms a day, is a different load from 200 people active at once across large federated rooms. Load follows concurrent syncs and federation, not the length of your member list.

Aspect Tuwunel Synapse
Scaling model Vertical only: one process, so you add cores and RAM to the same machine Vertical first, then horizontal by splitting work into worker processes
Use of multiple cores Built in, since the async Rust runtime spreads work across threads Limited in one process by the Python global interpreter lock, so workers are the way to use more cores
Extra parts when scaling None Redis for replication, generic_worker processes declared with worker_app: synapse.app.generic_worker, and reverse proxy rules routing endpoints to each worker
High availability Not available, since one process owns the RocksDB files Workers spread load, but the main process and PostgreSQL remain single points unless you build more
Sign you have outgrown it Sync requests slow down while the host CPU sits near full on every core The main Synapse process pins one core at full while others sit idle

For a group of 200 that mostly talks in its own rooms, the deciding factor is the hardware under Tuwunel, not a hard ceiling in the software. Synapse's advantage only appears once one machine is no longer enough. Then workers let you spread load in a way Tuwunel cannot.

That makes the decision easier than it looks. If you expect to grow steadily past a few hundred active people, starting on Synapse avoids a forced change later. If 200 is your realistic ceiling, workers solve a problem you are unlikely to have.

What hardware do you need for 10, 50 and 200 users?

Treat these tiers as starting points to confirm with docker stats and the weekly disk readings from earlier, not as guarantees. The two variables that move a group up a tier are wide federation and heavy media sharing, not headcount alone.

Group profile Tuwunel Synapse
10 users, private rooms only A Raspberry Pi 5 booting from SSD, an N100 mini PC or the smallest VPS tier your provider sells The same class of machine works, but PostgreSQL shares the RAM, so pick the larger memory option, such as the 8 GB Pi 5
10 users who join big public rooms Step up to a mini PC or a VPS with several cores, because state resolution on joins is the bottleneck Same step up, plus fast SSD storage for PostgreSQL, since join bursts write heavily
50 users, mixed private and federated A 4-core mini PC or VPS with RAM to spare for caches is a comfortable target A 4-core machine with PostgreSQL tuned, and a plan for moving federation to workers later
200 users, active daily A modern multi-core machine with generous RAM, since vertical growth is the only path Plan workers and Redis from the start, or a second machine for PostgreSQL
Storage at any size SSD or NVMe, never an SD card, with large free space for RocksDB compaction SSD or NVMe for PostgreSQL; media can live on slower bulk disk

Where the box lives is a separate choice from its size. A self-managed VPS gives you a fixed public IP and fast upgrades. A home server or a NAS uses hardware you already own but needs port 443 and federation reachable from outside. Yundera is another option in that list, running the homeserver as a container on a dedicated server with a public HTTPS subdomain already routed.

Running each server in Docker: containers, compose files and moving parts

The container count is where the two projects feel most different on day one. Both run well in Docker, but one docker-compose.yml stays short and the other grows with your group.

  • Tuwunel stack: one service for the homeserver and one volume for its RocksDB data and media. Configuration comes from tuwunel.toml or from environment variables with the TUWUNEL_ prefix, such as TUWUNEL_SERVER_NAME. An upgrade is a new image tag and a restart.
  • Synapse stack: the matrixdotorg/synapse image plus a postgres service, each with its own volume. You first generate homeserver.yaml by running the image with the generate command and SYNAPSE_SERVER_NAME set, then switch its database section to PostgreSQL. Adding workers later means more services, a redis container and per-worker config files.
  • Reverse proxy for both: Caddy, Traefik or nginx terminates TLS and forwards client traffic. Port 8448 is the default federation port, but most setups serve federation on 443 instead.
  • Delegation files for both: if your Matrix IDs use example.com but the server lives on matrix.example.com, you must serve /.well-known/matrix/server and /.well-known/matrix/client from the main domain. A missing or wrong file is the most common reason federation fails.
  • Health checks: test federation with the Matrix Federation Tester after every proxy or DNS change, since clients can work fine while federation is broken.

Who builds this stack varies by host. On a self-managed VPS, a home server or a NAS, you write the compose file and proxy rules yourself. On Yundera, apps are installed from an app store in one click and get a public HTTPS subdomain through NSL.SH mesh routing, though the delegation files on your own domain remain your job.

Voice and video calls: the TURN and LiveKit cost neither server removes

Discord users expect voice channels, and Slack users expect huddles. Matrix can cover both, but neither Tuwunel nor Synapse carries audio or video itself. Calls need separate services, and those services often cost more bandwidth than the homeserver costs in CPU.

  • One-to-one calls through TURN: Element's classic calls are peer-to-peer WebRTC. When both people sit behind strict NAT, the media goes through a TURN relay, usually coturn. It listens on 3478 for UDP and TCP, 5349 for TLS, and a wide UDP range for relayed media. Both homeservers hand out TURN credentials: Synapse through turn_uris and turn_shared_secret in homeserver.yaml, Tuwunel through turn_uris and turn_secret in tuwunel.toml.
  • Group calls through Element Call: multi-person calls use MatrixRTC with a LiveKit SFU and a small JWT service that issues LiveKit tokens. You advertise it in /.well-known/matrix/client under the org.matrix.msc4143.rtc_foci key. That is two more containers whichever homeserver you chose.
  • Bandwidth is the real bill: an SFU forwards every participant's stream to every other participant. Upload bandwidth, not CPU, is usually the first limit on a home connection, so a home server that handles chat easily can still struggle with a five-person video call.
  • Placement choice: run TURN and LiveKit on the same host to keep things simple, or put them on a VPS with good upstream while the homeserver stays at home.
  • Jitsi as a fallback: Element can embed Jitsi Meet as a room widget. It is another stack to run, but it is mature and needs no MatrixRTC support.

Plan the call stack as its own line item. It decides your network needs more than the Tuwunel versus Synapse choice does.

What do Slack and Discord users give up, and what do they gain?

The server choice barely changes this list. Both run the same Matrix protocol and the same clients, so the change in what your users experience comes from leaving a commercial platform, not from Tuwunel or Synapse.

Area Slack or Discord Matrix on Tuwunel or Synapse
Message history Slack's free plan only shows the last 90 days Kept as long as your disk and retention settings allow
Encryption Messages are readable by the provider End-to-end encryption, on by default in private rooms in Element
Search Fast server-side search across everything Server-side search works in unencrypted rooms only; encrypted rooms rely on local indexing in Element Desktop
Structure Workspaces, servers, channels and threads Spaces, rooms and threads map closely, though moderation tools are less polished
Integrations Large app directories and workflow builders Fewer ready-made bots; bridges such as mautrix-slack and mautrix-discord link old channels during the move
Polish One official app that mostly behaves the same everywhere Element, Element X, FluffyChat and others, which differ in features and maturity
Account control The provider can suspend accounts or change plans Your server, your rules, and federation with any other Matrix server

The losses that hurt most in practice are search inside encrypted rooms and the smaller integration ecosystem. Slack teams that lean on Workflow Builder or dozens of connected apps feel this sooner than Discord groups that mostly chat and call.

The gains build up over time. No message wall, no per-seat bill and no platform policy changes outside your control. Bridges ease the transition, but each one is an extra service with its own resource cost, so retire them once your group has moved.

How much does it really cost over 3 years compared to a subscription?

Prices change too often to quote reliably, so build the comparison from your own numbers. What does not change is the shape of each cost. Subscriptions scale with headcount. Self-hosting scales with hardware and your time.

  • Subscription side: seats × monthly price per seat × 36. A per-seat Slack plan grows in a straight line with every person you add. For Discord, the server is free, so the cost is what members spend on Nitro for upload limits and stream quality, plus the 90-day history wall your group already knows from Slack's free plan.
  • Hardware, paid once: a Pi 5, a mini PC or a reused machine. Spread over 36 months, even a modest box costs little per month. Tuwunel's smaller footprint can mean buying one size down, or using a machine you already own.
  • Electricity for a home box: average watts × 26,280 hours in 3 years ÷ 1,000 gives kWh. Multiply by your tariff. Measure with a plug-in power meter rather than trusting the label.
  • VPS instead of hardware: monthly plan × 36. Synapse with PostgreSQL may need the next tier up compared with Tuwunel, and call relays may push bandwidth into paid overage.
  • Fixed extras: a domain renewed 3 times, and optionally a backup target such as object storage.
  • Your time: hours per month × 36 × what an hour is worth to you. This is where Synapse's extra containers, PostgreSQL upgrades and table compression show up, and it often outweighs the hardware gap.

The break-even comes early for groups that would pay per seat, and late or never for a small Discord group that paid nothing. For them, the argument is control rather than savings.

Backups, upgrades and recovery: how much admin time each server takes

A homeserver backup has one job: let you rebuild under the same server name without breaking federation or losing history. The two servers ask for different routines to get there.

Task Tuwunel Synapse
What to back up The RocksDB data directory, media and tuwunel.toml A pg_dump -Fc of the database, the media_store directory, homeserver.yaml and the *.signing.key file
Consistent backups while running Built-in RocksDB backups via database_backup_path in the config, or stop the container and copy the volume pg_dump runs live; copy the media directory alongside it
Routine upgrades Pull the new image tag and restart one container Pull the new image, read the upgrade notes for config or database changes, restart Synapse and any workers
Database engine upgrades None, since RocksDB ships inside the binary Planned PostgreSQL major upgrades with pg_upgrade or a dump and restore
Restore drill Restore one directory and the config, then start the container Restore PostgreSQL first, then media, config and signing key, then start Synapse

The signing key deserves its own warning. If you lose a Synapse signing key, other servers can no longer verify your old events. Keep it in at least two places outside the server.

One thing no server backup covers is your users' encryption keys. Those live on their devices. Ask everyone to turn on Secure Backup in Element on day one, or a lost phone means lost encrypted history, however good your server backup is.

Test a full restore at least once on a spare machine before you rely on it. In practice, Tuwunel's restore drill is shorter. Synapse's is longer but uses tools most administrators already know.

Data sovereignty: where your messages live after you leave Slack

Self-hosting moves your messages from a vendor's multi-tenant cloud to a disk you control. With Matrix there is a twist: federation copies room history to every server that has members in that room. Sovereignty is complete only for rooms that stay on your own server.

Advantages you gain

  • Location you choose: the database sits in the country and on the hardware you pick, which simplifies GDPR conversations for European groups.
  • No vendor access to content: with end-to-end encryption, even your own server stores ciphertext, and no third party holds a copy of your keys.
  • Retention on your terms: you decide how long history lasts, not a pricing tier with a 90-day window.
  • No lock-in: Matrix is an open protocol, so clients and bridges keep working whichever homeserver you run.

Checklist before you call it sovereign

  • Decide on federation: for a closed group, turn it off with allow_federation = false in tuwunel.toml, or an empty federation_domain_whitelist in Synapse's homeserver.yaml. Rooms you share with outside servers live on their disks too.
  • Know your metadata: encryption hides content, not who talked to whom and when. The homeserver still logs that.
  • Encrypt the disk: full-disk encryption protects the database and media if the machine is stolen or a VPS disk is reused.
  • Keep backups in the same jurisdiction: an off-site copy in another country undoes your location choice.
  • Write down an exit plan: export procedures for users and a plan for the server name if you ever shut down.

None of this depends on Tuwunel versus Synapse. Both keep data where you put it. The choice that matters is where you put it.

Which Matrix server should you choose for your group?

Match your group to the closest row. If two rows fit, the one with more users or more federation usually wins.

Profile Recommendation Main reason
Family of 6 leaving WhatsApp groups and Discord Tuwunel One container, no database to maintain
Gaming clan of 25 that lives in voice Tuwunel, with LiveKit on a host with good upload Calls, not the homeserver, decide the hardware
Homelabber with a Pi 5 already running other services Tuwunel Leaves the most headroom on shared hardware
Open source project of 50 with bots built for Synapse Synapse Admin API and bot compatibility outweigh the extra containers
Startup of 40 expecting to triple within 2 years Synapse Workers give a growth path Tuwunel cannot offer
Company of 200 with an identity provider and audit needs Synapse with PostgreSQL Mature SSO, admin tooling and widely documented operations
Privacy group of 15 with federation turned off Tuwunel Smallest footprint for a closed server
Team already running Synapse without trouble Stay on Synapse No supported migration, and the server name is permanent

Next steps

If you chose Tuwunel:

  1. Pick your server name carefully, since it cannot change.
  2. Deploy one container behind a reverse proxy and publish the delegation files.
  3. Set presence, upload limits and cache sizes in tuwunel.toml before inviting users.
  4. Configure database_backup_path and test a restore.

If you chose Synapse:

  1. Create the PostgreSQL database with C collation.
  2. Generate homeserver.yaml, switch it to PostgreSQL and copy the signing key off the server.
  3. Schedule synapse_auto_compressor and watch autovacuum.
  4. Write down the worker layout you will adopt once one core stays saturated.

For both, run the Matrix Federation Tester and turn on Secure Backup for every user on day one.