mailu.io

Mailu is a full-featured mail server delivered as a set of Docker images. It is free and open-source software, and it deliberately avoids proprietary components and unrelated groupware features. It fits people who want to run their own mail server that is relatively easy to set up and maintain, without assembling every component by hand.

What Mailu actually is

Mailu packages the pieces of a working mail system into Docker images that you run together. According to the project's own description, it is "a simple yet full-featured mail server as a set of Docker images," and it is "free software (both as in free beer and as in free speech)." The stated goal is to give people an easily set-up, easily maintained, full-featured mail server while not shipping proprietary software or unrelated features often found in popular groupware.

That last point matters when you compare it with groupware suites. Mailu is not trying to be a calendar, file-sync, or chat platform. It is a mail server, and its feature list stays inside that boundary.

Main features

The project lists these capability areas:

• Standard email server — IMAP and IMAP+, SMTP and Submission, with auto-configuration profiles for clients.
• Advanced email features — aliases, domain aliases, custom routing, and full-text search of email attachments.
• Web access — multiple webmails and an administration interface.
• User features — aliases, auto-reply, auto-forward, fetched accounts, and managesieve.
• Admin features — global admins, announcements, per-domain delegation, and quotas.
• Security — enforced TLS, DANE, MTA-STS, Let's Encrypt integration, outgoing DKIM, an anti-virus scanner, Snuffleupagus, and blocking of malicious attachments.
• Antispam — auto-learn, greylisting, DMARC and SPF handling, and anti-spoofing.
• Freedom — all FOSS components, no tracker included.

How it is deployed

Mailu runs on Docker. The documentation covers two main paths:

• Docker Compose setup, with documented Docker Compose requirements.
• Kubernetes setup.

There is also a configuration reference, guidance on setting up your DNS, using an external reverse proxy, and changing the database back-end. Administration topics include maintaining a server, the web administration interface, spam filtering, a command-line tool, and a RESTful API.

Because the documentation is written as part of the repository and evolves with it, you should read the version of the docs that matches the Mailu version you are running.

Who it is for

Mailu suits you if:

• You want to self-host email and are comfortable running Docker.
• You want a mail server rather than a full collaboration suite.
• You value an all-FOSS stack with no tracker.
• You want a documented path for DNS, TLS, antispam, and administration instead of wiring each piece yourself.

It is probably not the right fit if you want a hosted service with no server to operate, or if you need calendar, contacts, and file sharing bundled in the same product.

Getting oriented

If you are evaluating Mailu, the project provides a demonstration server with instructions for connecting to it and adding domains, plus a features-and-screenshots section and an FAQ. A practical first pass is to read the general concepts, then the setup section for your chosen deployment model (Docker Compose or Kubernetes), and then the DNS and reverse-proxy configuration pages, since mail delivery and TLS depend on those being correct.

Mailu is administered through three complementary interfaces: the web administration interface for day-to-day domain, user, and alias management; the mailu command-line tool for host-level operations; and a RESTful API for automation. Spam filtering runs as a separate service with its own auto-learning and greylisting behavior. This guide covers what each interface does, how to reach it, and what to check when something stops working.

The web administration interface

The admin interface is the primary place for routine changes. According to the project documentation, it covers:

• Global admins — accounts that can manage every domain on the server.
• Per-domain delegation — you can hand a domain to a manager who only sees that domain, without granting global rights.
• Announcements — messages shown to users in the webmail.
• Quotas — per-user storage limits.

Typical tasks and where they live:

The same interface also exposes user-facing features — aliases, auto-reply, auto-forward, fetched accounts, and ManageSieve — so most requests from end users can be resolved without touching the server shell.

The Mailu command line

The mailu CLI is the tool for operations that sit outside the web UI: inspecting container state, running maintenance commands, and performing upgrades. Because Mailu ships as a set of Docker images, most command-line work happens in the context of your Docker Compose (or Kubernetes) deployment rather than inside a single long-running process.

Practical pattern:

1. Input — you run a mailu subcommand from the directory holding your docker-compose.yml (or against the Kubernetes deployment).
2. Action — the command acts on the running stack, for example to check status or apply a configuration change.
3. Expected result — the stack reflects the change, and docker compose ps (or the equivalent) shows the affected containers healthy again.

If a command appears to do nothing, confirm you are in the deployment directory and that your environment variables (domain, hostnames, secrets) are the ones the running stack was started with — a mismatch between the shell environment and the deployed configuration is the most common cause of confusing CLI behavior.

The RESTful API

For anything you would otherwise repeat by hand — bulk user creation, syncing accounts from an external directory, wiring Mailu into a provisioning pipeline — use the RESTful API instead of scripting the web UI. The API is documented alongside the rest of the project documentation, and it exposes the same administrative objects the web interface manages.

Two maintenance notes that matter here:

• Version your documentation. The docs are written inside the repository and evolve with it. Always read the documentation matching the Mailu version you actually run — a 2024.06 server should be read against the 2024.06 docs, not the latest.
• Pin your image tags. Because the project ships versioned releases (2024.06, 2.0, 1.9, and earlier), an unpinned latest tag turns a routine restart into an unplanned upgrade.

Spam filtering and security maintenance

Antispam is a first-class part of Mailu rather than an add-on. The documented capabilities include:

• Auto-learn — the filter adjusts from mail it has classified.
• Greylisting — temporary deferral of unknown senders.
• DMARC and SPF — policy checks against your published DNS records.
• Anti-spoofing — rejection of forged sender identities.

On the security side, Mailu enforces TLS and supports DANE, MTA-STS, Let's Encrypt certificate issuance, outgoing DKIM signing, an anti-virus scanner, Snuffleupagus hardening, and blocking of malicious attachments.

Maintenance implications:

• DNS is part of the server. SPF, DKIM, DMARC, MTA-STS, and DANE all depend on records you publish. If mail is being rejected or marked as spam by recipients, check DNS before touching the Mailu configuration.
• Certificates renew on their own when Let's Encrypt is configured, but renewal fails silently if DNS or the reverse proxy is misconfigured. Verify after any DNS or proxy change.
• Auto-learn means behavior drifts. A filter that has learned from a mislabeled message will keep applying that lesson; correct misclassifications rather than ignoring them.

Routine maintenance checklist

• Before upgrading: read the release notes for the target version and the matching documentation version. The project publishes notes per release (2024.06, 2.0, 1.9, 1.8, and back to Freeposte.io 1.2), and breaking changes are listed there.
• Back up the database. Mailu supports more than one database back-end, and the documentation includes a section on changing it — which means the database is a component you can and should treat as movable and backed up.
• Review delegation and global admins periodically. Per-domain delegation is a convenience that is easy to forget after staff changes.
• Watch quotas. Quota exhaustion is a common, easily-missed cause of "mail stopped arriving."
• Keep the reverse proxy in mind. Mailu documents using an external reverse proxy; if TLS or webmail breaks after a proxy change, that is the first place to look.

Common sticking points

• Reading the wrong docs version. The documentation is versioned with the code. Mismatched docs produce instructions that do not match your menus.
• Treating the web UI as the only interface. Bulk or repeatable work belongs in the API; host-level work belongs in the CLI.
• Assuming spam settings are static. Auto-learn and greylisting change over time; review rather than set-and-forget.
• Forgetting that DNS is configuration. DKIM, SPF, DMARC, MTA-STS, and DANE are all DNS-side, and all can break mail delivery without any change on the server itself.

Where to start

If you are new to the server, work through the setup documentation for your version first, then use the demonstration server to see the admin interface and webmail before configuring your own. Once running, treat the web admin interface as your daily tool, the CLI as your maintenance tool, and the API as your automation tool — and keep the documentation version aligned with the Mailu version you deployed.

Mailu's documentation lives inside the project repository and evolves together with the code, so the version you read matters: you should open the documentation that matches the Mailu version you are actually running. Release notes for each version are listed alongside it, and a demonstration server is available if you want to see the interface and features before or after installing.

Documentation Structure

The docs are organized into a few main sections, which map to the tasks you will actually perform:

• General — concepts, philosophy, history, features and screenshots, admin interface screenshots, FAQ, and release notes.
• Setup — setting up a new Mailu server, Docker Compose requirements, Docker Compose setup, Kubernetes setup, configuration reference, setting up your DNS, using an external reverse proxy, and changing the database back-end.
• Administration — maintaining a Mailu server, the web administration interface, spam filtering, the Mailu command line, and the Mailu RESTful API.
• Contributors — contribution workflow, project guidelines, development environment, altering the database, before requesting a pull, I18N and L10N, and firewalling Mailu.

Because the documentation is written as part of the repository, it changes with each release. A page that describes a configuration option or a setup step may not apply to an older or newer Mailu version than the one it was written for.

Matching Docs to Your Version

The key rule stated in the documentation itself: make sure you access the proper version of the documentation, based on the version of Mailu you are running. In practice this means:

1. Check which Mailu version your deployment uses (for example, from your Docker Compose configuration or the release you installed).
2. Open the documentation set for that same version rather than the latest one.
3. When a step does not match what you see, treat the version mismatch as the first thing to verify.

This matters most for Setup and Administration pages, where commands, environment variables, and interface behavior can differ between releases.

Release Notes and Version History

Release notes give you the version timeline and what changed in each release. The documented releases include:

Use the release notes when you need to know whether a feature, fix, or behavior change exists in your version — for example, before following a setup guide written for a different release.

Demonstration Server

A demonstration server is documented for exploring functionality and connecting to the server, including adding domains. It is useful when you want to see the admin interface and mail features in action without committing to a full deployment, or when you are deciding whether Mailu fits your needs.

What Mailu Is, in One Paragraph

Mailu is a mail server delivered as a set of Docker images, described as free software in both senses (free of cost and open source), open to suggestions and external contributions. Its stated aim is an easily set up, easily maintained, full-featured mail server that ships no proprietary software and no unrelated features common in groupware. Documented features include a standard email server (IMAP/IMAP+, SMTP and Submission with client auto-configuration profiles), aliases, domain aliases, custom routing, full-text search of attachments, multiple webmails and an administration interface, user features such as auto-reply, auto-forward, fetched accounts and managesieve, admin features such as global admins, announcements, per-domain delegation and quotas, security features including enforced TLS, DANE, MTA-STS, Letsencrypt, outgoing DKIM, anti-virus scanning, Snuffleupagus and malicious attachment blocking, and antispam with auto-learn, greylisting, DMARC and SPF, and anti-spoofing.

Practical Checklist

• Confirm your running Mailu version before reading any setup or admin page.
• Read the documentation version that matches it, not the newest one.
• Consult release notes to place a feature or change in the correct version.
• Use the demonstration server to preview functionality and the connection flow.
• Expect the docs to move with the repository, so re-check after upgrading.

Mailu is a full-featured mail server delivered as a set of Docker images, and you set it up by choosing a deployment method (Docker Compose or Kubernetes), meeting that method's requirements, configuring DNS, and then running the stack. The Docker Compose path is the standard starting point; Kubernetes is an alternative for those already running a cluster. Both are documented in the project's own docs, which are written as part of the repository and evolve with it — so match the documentation version to the Mailu version you run.

What Mailu gives you before you start

Knowing the scope helps you decide whether it fits your environment. Per the project, Mailu is free software (both as in free beer and as in free speech), open to suggestions and external contributions, and aims to be easily set up, easily maintained, and full-featured without shipping proprietary software or unrelated groupware features.

Its stated main features:

• Standard email server — IMAP and IMAP+, SMTP and Submission, with auto-configuration profiles for clients
• Advanced email features — aliases, domain aliases, custom routing, full-text search of email attachments
• Web access — multiple webmails and an administration interface
• User features — aliases, auto-reply, auto-forward, fetched accounts, managesieve
• Admin features — global admins, announcements, per-domain delegation, quotas
• Security — enforced TLS, DANE, MTA-STS, Letsencrypt, outgoing DKIM, anti-virus scanner, Snuffleupagus, blocking of malicious attachments
• Antispam — auto-learn, greylisting, DMARC and SPF, anti-spoofing
• Freedom — all FOSS components, no tracker included

If you need a mail server you can maintain yourself without proprietary components, this feature set is the baseline you are deploying.

Choose a deployment method

Both paths share the same configuration reference and the same post-setup tasks, so the choice mainly affects how the containers are orchestrated, not what the mail server does.

Prerequisites

Before configuring anything, work through the items the documentation groups under Setup:

1. Meet the Docker Compose requirements. The docs list "Docker compose requirements" as its own topic — check this before writing any configuration, since it defines what your host must provide.
2. Set up your DNS. "Setting up your DNS" is a required step in the setup sequence, not an optional extra. Mail delivery and client auto-configuration depend on it.
3. Decide on optional components (see the next section) so you configure them in one pass rather than retrofitting later.

Optional choices to make up front

The documentation exposes these as configuration decisions:

• External reverse proxy — "Using an external reverse proxy" is a documented configuration option, relevant if you already terminate TLS or route traffic elsewhere.
• Database back-end — "Changing the database back-end" is documented, so the default can be swapped if you have an existing database to use.

Deciding these before you deploy avoids reconfiguring a running server.

Setup steps

1. Confirm the Docker Compose requirements for your host.
2. Follow the Docker Compose setup (or the Kubernetes setup) to produce your configuration and bring up the stack.
3. Configure DNS as described in "Setting up your DNS."
4. Apply optional configuration — external reverse proxy and/or database back-end — if you chose them above.
5. Verify using the project's own demonstration server, which documents its functionality, how to connect to it, and how to add domains. Comparing your instance against the demo is a concrete way to confirm the web interface and mail flow behave as expected.

After setup: administration

Once running, Mailu is maintained through several documented surfaces:

• Web administration interface
• Mailu command line
• Mailu RESTful API
• Spam filtering settings
• Maintain a Mailu server — the general upkeep topic

For contributors, the docs also cover the contribution workflow, project guidelines, development environment, altering the database, the pull-request checklist, I18N and L10N, and firewalling.

Common sticking points

• Version mismatch with the docs. The documentation is written as part of the repository and evolves with it. The docs explicitly warn to access the proper version based on the Mailu version you are running — a mismatch is an easy way to follow instructions that no longer apply.
• Skipping DNS. Because "Setting up your DNS" sits inside the setup sequence, treating it as an afterthought tends to surface later as delivery or client-configuration problems.
• Ignoring the Compose requirements. These are listed as a distinct prerequisite, so verify them before debugging configuration.

Where to look next

The documentation's General section covers general concepts, philosophy, history, features and screenshots, admin interface screenshots, and a FAQ split into informational, deployment-related, and technical-issues categories. Release notes run from the current 2024.06 release back through Mailu 2.0, 1.9, 1.8, 1.7, 1.6, 1.5, 1.3, and the earlier Freeposte.io 1.2 and 1.1 releases — useful if you are running or upgrading an older version. Note that "upgrade" appears in the site's own keyword signals, so check the release notes for your version before moving between releases.

Mailu is a full-featured mail server delivered as a set of Docker images, and it is free software — free both as in cost and as in freedom. It is designed to be easy to set up and maintain without shipping proprietary software or unrelated groupware features. If you want a self-hosted mail server that covers standard mail protocols, webmail, administration, security, and antispam in one stack, Mailu is built for that purpose. The feature list below reflects what the project documents on its own site.

Standard email server

Mailu provides the core protocols you expect from a mail server:

• IMAP and IMAP+ for mailbox access
• SMTP and Submission for sending and relaying mail
• Auto-configuration profiles for clients, so mail clients can be set up with less manual entry

This means Mailu can serve as the primary mail server for a domain, handling both incoming and outgoing mail alongside mailbox retrieval.

Advanced email features

Beyond basic delivery, Mailu documents several features that matter for real-world mail management:

• Aliases — route mail to alternate addresses
• Domain aliases — serve multiple domain names from one setup
• Custom routing — control how messages are directed
• Full-text search of email attachments — search inside attached files, not just message bodies

Web access

Mailu includes a browser-based side to the server:

• Multiple Webmails — more than one webmail option is available
• Administration interface — manage the server through the web

User features

For individual accounts, Mailu documents:

• Aliases
• Auto-reply
• Auto-forward
• Fetched accounts (pulling mail from external accounts)
• ManageSieve (for server-side mail filtering rules)

Admin features

Administrators get tools for running the server across one or many domains:

• Global admins
• Announcements
• Per-domain delegation
• Quotas

Security

Mailu documents a security-focused feature set:

• Enforced TLS
• DANE
• MTA-STS
• Let's Encrypt integration
• Outgoing DKIM
• Anti-virus scanner
• Snuffleupagus
• Blocking of malicious attachments

Antispam

Spam handling in Mailu includes:

• Auto-learn
• Greylisting
• DMARC and SPF
• Anti-spoofing

Freedom and openness

Mailu is built entirely from FOSS components and includes no tracker. The project is open to suggestions and external contributions. Its documentation is written as part of the repository and evolves with it, so you should consult the documentation version that matches the Mailu version you are running.

How to decide whether Mailu fits your needs

Use the list above as a checklist against your requirements:

If your requirements map cleanly onto these documented features, Mailu is a candidate worth evaluating. If you need functionality outside this list — such as groupware or proprietary integrations — note that Mailu explicitly does not ship unrelated features often found in popular groupware, so those would need to come from elsewhere.