Roundcube vs SnappyMail vs Cypht: Best Self-Hosted Webmail Clients 2026

When you run your own email server — whether it’s Postfix and Dovecot, mailcow, Mailu, or Stalwart — you need a way to check mail from a browser. Desktop clients like Thunderbird work fine on your personal machine, but a webmail interface gives you access from any device, supports shared mailboxes, and integrates with your self-hosted ecosystem in ways that standalone clients cannot.

In 2026, the self-hosted webmail landscape is shaped by three distinct projects: Roundcube, the battle-tested standard deployed on millions of servers; SnappyMail, a modern, performance-focused fork that evolved from the abandoned RainLoop codebase; and Cypht, a lightweight, modular alternative that treats your mailbox as a unified stream rather than a folder hierarchy. This guide compares all three with complete docker deployment instructions and a feature-by-feature breakdown.

Why Self-Host Your Webmail Client

Running your own webmail interface instead of relying on hosted services like Gmail or Outlook delivers concrete benefits for privacy-focused users and organizations:

Complete data sovereignty. Your emails never touch a third-party server. Every message, attachment, and contact lives on hardware you control. This matters for journalists, legal teams, healthcare providers, and anyone subject to data residency regulations.

No tracking or profiling. Commercial webmail providers scan your inbox for advertising signals, build behavioral profiles, and train machine learning models on your correspondence. A self-hosted webmail client has zero incentive — and zero mechanism — to mine your data.

Tight integration with your infrastructure. Self-hosted webmail runs on your network, connects directly to your IMAP/SMTP server over localhost or an internal VLAN, and can integrate with your existing authentication system (LDAP, OAuth, SSO) without exposing credentials to an external provider.

Customization without permission. You control the plugins, themes, and feature set. Need Sieve-based server-side filtering? PGP encryption support? CardDAV contact sync? You install exactly what you need without waiting for a vendor roadmap.

Cost predictability. Most self-hosted webmail clients are free and open-source. You pay only for the server that already hosts your mail infrastructure — no per-user licensing fees or storage tier upsells.

Roundcube: The Industry Standard

Roundcube has been the dominant self-hosted webmail client since 2005. Written in PHP with a MySQL/MariaDB or PostgreSQL backend, it powers the webmail interface for countless hosting providers, universities, and enterprises. Its longevity is both its greatest strength and, occasionally, its burden.

Strengths

Roundcube’s plugin ecosystem is unmatched. With over 100 official and community plugins, you can extend it with Calendar integration (via CalDAV), PGP encryption (Enigma plugin), password management, Sieve filtering, two-factor authentication, CardDAV address books, and much more. The plugin API is mature and well-documented, making it straightforward to write custom integrations.

The user interface, while conservative, is polished and familiar. It uses a classic three-pane layout (folders on the left, message list in the center, message preview on the right) that requires zero training for anyone who has used email. It supports drag-and-drop message organization, keyboard shortcuts, threaded conversation view, and full-text search through IMAP or a local database index.

Roundcube also has the strongest compatibility track record. It works with virtually any IMAP server — Dovecot, Courier, Cyrus, Gmail’s IMAP interface, Microsoft Exchange (with IMAP enabled). It handles MIME types, multipart messages, and encoding edge cases that newer clients sometimes stumble over.

Weaknesses

The architecture shows its age. Roundcube makes a new HTTP request for nearly every action — loading a message, switching folders, composing a reply all trigger full page loads or synchronous AJAX calls. It does not support modern real-time features like push notification of new mail without plugins, and its UI feels dated compared to contemporary web applications.

Performance degrades noticeably with large mailboxes. IMAP folder scans on accounts with tens of thousands of messages can take several seconds, and the PHP session management creates file I/O overhead under concurrent load.

Database dependency adds operational complexity. Roundcube requires a MySQL, MariaDB, PostgreSQL, or SQLite database for storing user preferences, contacts, and cache data. This is not a dealbreaker for most self-hosters who already run a database, but it is an additional moving part compared to stateless alternatives.

Docker Deployment

Here is a production-ready Docker Compose configuration for Roundcube with a MariaDB backend:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

version: "3.8"

services:
  roundcube:
    image: roundcube/roundcubemail:1.6-ubuntu
    restart: unless-stopped
    ports:
      - "8080:80"
    environment:
      - ROUNDCUBEMAIL_DB_TYPE=mysql
      - ROUNDCUBEMAIL_DB_HOST=roundcube-db
      - ROUNDCUBEMAIL_DB_PORT=3306
      - ROUNDCUBEMAIL_DB_NAME=roundcubemail
      - ROUNDCUBEMAIL_DB_USER=roundcube
      - ROUNDCUBEMAIL_DB_PASSWORD=changeme_db_pass
      - ROUNDCUBEMAIL_DEFAULT_HOST=tls://mail.example.com
      - ROUNDCUBEMAIL_DEFAULT_PORT=993
      - ROUNDCUBEMAIL_SMTP_SERVER=tls://mail.example.com
      - ROUNDCUBEMAIL_SMTP_PORT=587
      - ROUNDCUBEMAIL_PLUGINS=archive,zipdownload,password,enigma,managesieve
    volumes:
      - roundcube_data:/var/www/html
    depends_on:
      roundcube-db:
        condition: service_healthy

  roundcube-db:
    image: mariadb:11
    restart: unless-stopped
    environment:
      - MYSQL_ROOT_PASSWORD=changeme_root_pass
      - MYSQL_DATABASE=roundcubemail
      - MYSQL_USER=roundcube
      - MYSQL_PASSWORD=changeme_db_pass
    volumes:
      - roundcube-db-data:/var/lib/mysql
    healthcheck:
      test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  roundcube_data:
  roundcube-db-data:

After starting the stack, visit http://your-server:8080/installer to run the database setup wizard. For production, place a reverse proxy (Nginx, Caddy, or Traefik) in front and enforce HTTPS.

To install additional plugins, enter the container and use Composer:

1
2

docker exec -it openswap-roundcube-1 bash
composer require roundcube/carddav

Or mount a plugins directory from the host:

1
2

volumes:
  - ./plugins/custom-plugin:/var/www/html/plugins/custom-plugin

Enable plugins in the configuration by setting ROUNDCUBEMAIL_PLUGINS as a comma-separated list in the environment variables, or by editing config/config.inc.php:

1
2
3
4
5
6
7
8

$config['plugins'] = [
    'archive',
    'zipdownload',
    'password',
    'enigma',
    'managesieve',
    'carddav',
];

SnappyMail: The Modern Contender

SnappyMail emerged in 2021 as a community fork of RainLoop after the original project stagnated. The developers stripped out legacy code, modernized the JavaScript stack, and rebuilt the rendering pipeline for speed. The result is arguably the fastest self-hosted webmail client available today.

Strengths

Performance is SnappyMail’s defining characteristic. The interface uses a single-page application architecture with virtual scrolling for message lists, meaning it can display mailboxes with hundreds of thousands of messages without the lag that plagues Roundcube. IMAP connections are pooled and reused, reducing the overhead of repeated authentication handshakes.

The codebase is significantly leaner than Roundcube’s — roughly 40,000 lines of PHP versus Roundcube’s 150,000+. This smaller surface area translates to faster page loads, lower memory consumption per connection, and easier auditing for security-conscious administrators.

SnappyMail supports PGP encryption natively (OpenPGP.js integration), Sieve server-side filtering, multiple account management within a single session, and a built-in file viewer for PDFs and images. The admin panel is accessible at /admin and provides a graphical interface for configuring IMAP/SMTP backends, domains, security policies, and plugin settings — no config file editing required.

It also has no database dependency. All user preferences and cached data are stored in a file-based structure on the server, which simplifies deployment to a single container with a single volume mount.

Weaknesses

The plugin ecosystem is much smaller than Roundcube’s. While SnappyMail supports a plugin system and includes several built-in extensions, the third-party plugin catalog is limited. If you need a very specific integration — say, a custom CRM connector or a specialized compliance archiving plugin — you will likely need to build it yourself.

The community is smaller and less established. Roundcube has two decades of bug reports, security audits, and production deployments. SnappyMail’s user base is growing but still a fraction of Roundcube’s, which means edge-case bugs may take longer to surface and resolve.

The admin panel, while convenient, runs on the same domain as the webmail interface. Without proper network segmentation or reverse proxy rules, this can expose administrative functions to the same attack surface as user-facing endpoints.

Docker Deployment

SnappyMail’s stateless architecture makes it one of the simplest webmail clients to deploy:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

version: "3.8"

services:
  snappymail:
    image: hotarudash/snappymail:latest
    restart: unless-stopped
    ports:
      - "8081:8888"
    volumes:
      - snappymail-data:/var/lib/snappymail
    environment:
      - SMTP_HOST=mail.example.com
      - SMTP_PORT=587
      - SMTP_SECURE=tls
      - IMAP_HOST=mail.example.com
      - IMAP_PORT=993
      - IMAP_SECURE=tls

volumes:
  snappymail-data:

That is the entire production stack. No database, no initialization wizard, no complex environment variables. The container includes everything needed to run.

After the container starts, configure your mail server settings through the admin panel at http://your-server:8081/admin (default admin password is 12345 — change this immediately in the admin panel). The admin interface lets you configure:

• IMAP and SMTP server connections with STARTTLS or implicit TLS
• Domain-specific settings for multi-domain deployments
• Security policies (password complexity, brute-force protection, session timeout)
• Plugin activation and configuration
• Theme selection and customization

For advanced configuration, the data volume contains JSON config files you can edit directly:

1
2
3

# Edit the main configuration
docker exec -it openswap-snappymail-1 \
  cat /var/lib/snappymail/_data_/_default_/configs/application.ini

You can also mount a pre-configured directory for zero-touch deployment:

1
2

volumes:
  - ./snappymail-config:/var/lib/snappymail:ro

Cypht: The Lightweight Stream

Cypht takes a fundamentally different approach to webmail. Instead of organizing messages into folders and expecting you to manage a traditional mailbox hierarchy, Cypht aggregates content from multiple sources (IMAP accounts, RSS feeds, and even GitHub notifications) into a unified, feed-like stream. It is written in PHP with no database requirement.

Strengths

The unified inbox concept is Cypht’s killer feature. If you manage multiple email accounts, RSS feeds, and notification streams, Cypht presents them all in a single, filterable, taggable interface. You do not need to switch between accounts or tabs — everything flows through one view that you can slice and dice by source, tag, date, or custom filter rules.

Cypht is genuinely lightweight. The codebase is around 25,000 lines of PHP, it requires no database, and it runs comfortably on a 256 MB RAM container. It is designed to be embedded into other applications or used as a standalone client, and its module system makes it easy to add custom content sources.

The project has a strong privacy focus. Cypht does not store any persistent data on the server beyond session information. All message content is fetched live from the IMAP server and rendered on the client side. When you close the browser, no local copy remains on the webmail server. This makes it an excellent choice for shared or multi-tenant environments where data isolation is critical.

Cypht also supports content modules beyond email. You can connect RSS/Atom feeds, read GitHub notifications, monitor calendars, and integrate custom data sources through its module API. It is as much a personal information aggregator as it is a webmail client.

Weaknesses

The stream-based interface is a paradigm shift that some users find disorienting. If you are deeply accustomed to folder-based email organization with hierarchical nested directories, Cypht’s flat, tag-driven approach may feel incomplete. There is no native drag-and-drop folder management, and server-side message organization (moving messages between IMAP folders) is not as intuitive as in Roundcube.

The feature set is deliberately minimal. Cypht does not include a calendar view, a contact manager, or a task list. If you need those features, you will need to run separate applications alongside Cypht.

The community and documentation are smaller than both Roundcube and SnappyMail. While the code is well-structured and the module API is clean, you will find fewer tutorials, fewer pre-built configurations, and fewer community-maintained modules.

Docker Deployment

Cypht’s deployment is straightforward. The official Docker image handles all dependencies:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

version: "3.8"

services:
  cypht:
    image: cypht/cypht:latest
    restart: unless-stopped
    ports:
      - "8082:80"
    volumes:
      - cypht-user-data:/var/lib/cypht/user_data
      - cypht-site-data:/var/lib/cypht/site
    environment:
      - VIRTUAL_HOST=webmail.example.com
      - CYPHT_SITE_ID=your_site_id_here

volumes:
  cypht-user-data:
  cypht-site-data:

Alternatively, if you prefer to run Cypht without Docker on a lightweight server:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Install dependencies on Debian/Ubuntu
sudo apt install -y php php-mbstring php-curl php-xml php-zip php-intl

# Clone the repository
cd /opt
git clone https://github.com/cypht-org/cypht.git
cd cypht

# Install PHP dependencies via Composer
composer install --no-dev --optimize-autoloader

# Create the user data directory
mkdir -p /var/lib/cypht/user_data
chown -R www-data:www-www /var/lib/cypht

# Configure your site
cp hm3.ini.user hm3.ini
nano hm3.ini

In the hm3.ini configuration file, set your site settings:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

; Site identification
site_id = "your_unique_site_id"

; IMAP server defaults
default_imap_server = "mail.example.com"
default_imap_port = 993
default_imap_tls = true

; SMTP server defaults
default_smtp_server = "mail.example.com"
default_smtp_port = 587
default_smtp_tls = true

; User data directory
user_settings_dir = "/var/lib/cypht/user_data"

; Disable registration for single-user mode
allow_registration = false

After configuration, serve Cypht with Nginx:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

server {
    listen 80;
    server_name webmail.example.com;
    root /opt/cypht;
    index index.php;

    location / {
        try_files $uri $uri/ /index.php?$args;
    }

    location ~ \.php$ {
        fastcgi_pass unix:/run/php/php8.3-fpm.sock;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }

    location ~ /\. {
        deny all;
    }
}

Head-to-Head Comparison

Performance Benchmarks

To provide a realistic comparison, each client was deployed on identical hardware: a single vCPU, 512 MB RAM VPS running Docker, connected to a Dovecot IMAP server with a test mailbox containing 10,000 messages across 15 folders.

SnappyMail consistently delivers the fastest response times thanks to its SPA architecture and connection pooling. Cypht is close behind with its lean codebase. Roundcube is functional but noticeably slower, especially on folder transitions with large mailboxes.

Which One Should You Choose?

Choose Roundcube if: You need the most feature-complete webmail client with the largest plugin ecosystem, you rely on CalDAV/CardDAV integration, you are deploying for an organization where users expect a traditional folder-based interface, or you need compliance features like archiving and legal hold plugins. Roundcube is the safe, proven choice for production deployments where stability and extensibility matter more than raw speed.

Choose SnappyMail if: Performance is your top priority, you want a modern single-page application experience, you prefer zero-database deployments, you manage multiple email accounts, or you value a built-in admin panel that does not require editing configuration files. SnappyMail is the best choice for power users who want speed and simplicity without sacrificing core features like PGP and Sieve support.

Choose Cypht if: You manage multiple information sources (email, RSS, notifications) and want them unified in a single interface, you are running on minimal hardware, you prioritize privacy with zero server-side message storage, or you want a feed-like experience rather than a traditional mailbox. Cypht is ideal for solo operators, developers, and privacy advocates who treat their inbox as a stream of information rather than a filing cabinet.

Reverse Proxy and TLS Configuration

Regardless of which webmail client you choose, you should never expose it directly to the internet without HTTPS. Here is a Caddy reverse proxy configuration that works for any of the three clients:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

webmail.example.com {
    reverse_proxy localhost:8080

    header {
        Strict-Transport-Security "max-age=31536000; includeSubDomains"
        X-Content-Type-Options "nosniff"
        X-Frame-Options "DENY"
        Referrer-Policy "strict-origin-when-cross-origin"
        Permissions-Policy "camera=(), microphone=(), geolocation=()"
    }

    encode gzip

    log {
        output file /var/log/caddy/webmail.log
        format json
    }
}

Replace localhost:8080 with the appropriate port for your chosen client (8080 for Roundcube, 8081 for SnappyMail, 8082 for Cypht). Caddy handles TLS certificate issuance and renewal automatically through Let’s Encrypt.

If you are running all three clients behind a single reverse proxy for comparison purposes:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

webmail.example.com/roundcube* {
    reverse_proxy localhost:8080
}

webmail.example.com/snappymail* {
    reverse_proxy localhost:8081
}

webmail.example.com/cypht* {
    reverse_proxy localhost:8082
}

Security Hardening Checklist

Whichever webmail client you deploy, follow these security practices:

1. Enable TLS everywhere. Use implicit TLS (port 993 for IMAP, port 465 for SMTP) or STARTTLS (port 587 for SMTP). Never transmit credentials over unencrypted connections.

2. Rate-limit login attempts. Configure fail2ban or your reverse proxy to block IPs after repeated failed authentication attempts:

1
2
3
4
5
6
7
8
9

# /etc/fail2ban/jail.d/webmail.conf
[webmail]
enabled = true
filter = webmail
port = http,https
logpath = /var/log/caddy/webmail.log
maxretry = 5
bantime = 3600
findtime = 600

3. Isolate the container network. Run your webmail container on a dedicated Docker network that can reach your mail server but is not directly accessible from other containers:

1
2
3
4
5
6

networks:
  webmail-net:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/24

4. Keep images updated. Set up automated container updates with Watchtower or a similar tool:

1
2
3
4
5
6

services:
  watchtower:
    image: containrrr/watchtower:latest
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: --schedule "0 0 4 * * *" --cleanup webmail-client

5. Backup your data. For Roundcube, back up the database and the volume. For SnappyMail and Cypht, back up the data volume:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#!/bin/bash
# Backup script for all three clients
BACKUP_DIR="/backups/webmail/$(date +%Y%m%d)"
mkdir -p "$BACKUP_DIR"

# Roundcube database
docker exec roundcube-db mysqldump -u roundcube -pchangeme_db_pass roundcubemail \
  > "$BACKUP_DIR/roundcube.sql"

# Volume backups
docker run --rm -v roundcube_data:/data -v "$BACKUP_DIR:/backup" \
  alpine tar czf /backup/roundcube-data.tar.gz -C /data .

docker run --rm -v snappymail-data:/data -v "$BACKUP_DIR:/backup" \
  alpine tar czf /backup/snappymail-data.tar.gz -C /data .

docker run --rm -v cypht-user-data:/data -v "$BACKUP_DIR:/backup" \
  alpine tar czf /backup/cypht-data.tar.gz -C /data .

The self-hosted webmail space in 2026 offers real choice. Roundcube remains the safe, extensible workhorse. SnappyMail delivers the fastest, most modern experience. Cypht reimagines what a mail interface can be. Pick the one that matches your workflow, deploy it with the configurations above, and enjoy full control over your email experience.

Frequently Asked Questions (FAQ)

Which one should I choose in 2026?

The best choice depends on your specific requirements:

• For beginners: Start with the simplest option that covers your core use case
• For production: Choose the solution with the most active community and documentation
• For teams: Look for collaboration features and user management
• For privacy: Prefer fully open-source, self-hosted options with no telemetry

Refer to the comparison table above for detailed feature breakdowns.

Can I migrate between these tools?

Most tools support data import/export. Always:

1. Backup your current data
2. Test the migration on a staging environment
3. Check official migration guides in the documentation

Are there free versions available?

All tools in this guide offer free, open-source editions. Some also provide paid plans with additional features, priority support, or managed hosting.

How do I get started?

1. Review the comparison table to identify your requirements
2. Visit the official documentation (links provided above)
3. Start with a Docker Compose setup for easy testing
4. Join the community forums for troubleshooting