Source: https://cli.nylas.com/guides/neomutt-vs-aerc-terminal-email

# neomutt vs aerc: Terminal Email Clients

neomutt and aerc are the two terminal email clients people actually compare. Both read your inbox in a text UI you drive from the keyboard, and both connect over IMAP. They differ in config style, how they handle a slow mailbox, and how much work it takes to authenticate against Gmail. Here's the head-to-head, plus where an API-backed client sidesteps the IMAP-and-app-password problem entirely.

Written by [Caleb Geene](https://cli.nylas.com/authors/caleb-geene) Director, Site Reliability Engineering

Updated June 8, 2026

> **TL;DR:** neomutt is the maintained fork of mutt — endlessly configurable, synchronous, decades of muttrc recipes online. aerc is the modern Go client — async by design, multiple accounts, embedded terminal for replies. Both speak IMAP, so both need an app password or an OAuth helper script to reach Gmail. The open question: what reads your inbox in a terminal *without* IMAP at all?

> **Disclosure:** Nylas CLI is built by Nylas, Inc. This comparison reflects our testing and product understanding as of June 8, 2026.

Command references used in this guide: [`nylas tui`](https://cli.nylas.com/docs/commands/tui), [`nylas email list`](https://cli.nylas.com/docs/commands/email-list), and [`nylas init`](https://cli.nylas.com/docs/commands/init).

## What are the best terminal email clients?

The three terminal email clients developers compare most are neomutt, aerc, and mutt. All render your mailbox as a keyboard-driven text interface and connect to mail servers over IMAP and SMTP. neomutt and aerc are the active choices in 2026; mutt still works but moves slowly, and most of its momentum migrated to the neomutt fork after 2016.

The split is philosophical. neomutt descends from a 1995 codebase and exposes hundreds of settings through a single config file, rewarding long customization. aerc, first released in 2019 and written in Go, is asynchronous from the ground up and ships with an embedded terminal so replies open `$EDITOR` without blocking the UI. Both are free and open source.

## How does neomutt work?

neomutt is a mail reader configured entirely through `~/.config/neomutt/neomuttrc`. You declare your IMAP folders, SMTP server, sidebar, key bindings, and color scheme as plain-text directives, then drive everything from the keyboard. The project, documented at [neomutt.org](https://neomutt.org/), ships a release roughly every quarter and inherits 30 years of mutt recipes you can paste in.

The cost is the IMAP connection. neomutt fetches headers synchronously, so opening a 50,000-message Gmail folder over IMAP can stall the UI for several seconds. Authenticating against Gmail needs more than a password: you set `$imap_authenticators` to `xoauth2` and point `$imap_oauth_refresh_command` at an external token script, or fall back to a 16-character [app password](https://support.google.com/accounts/answer/185833) under 2-Step Verification.

```ini
# ~/.config/neomutt/neomuttrc — Gmail over IMAP
set imap_user = "you@gmail.com"
set folder = "imaps://imap.gmail.com:993"
set spoolfile = "+INBOX"
set smtp_url = "smtps://you@gmail.com@smtp.gmail.com:465"

# OAuth needs an external refresh-token helper script:
set imap_authenticators = "xoauth2"
set imap_oauth_refresh_command = "/path/to/oauth2.py you@gmail.com"
# ...or an app password in smtp_pass / imap_pass instead.
```

## How does aerc work?

aerc is an asynchronous TUI mail client written in Go, configured through three files in `~/.config/aerc/`: `accounts.conf`, `aerc.conf`, and `binds.conf`. Because every IMAP operation runs off the main thread, the message list stays responsive while a large folder loads in the background. It handles multiple accounts as tabs and supports IMAP, JMAP, Maildir, and notmuch backends, per [aerc-mail.org](https://aerc-mail.org/).

aerc's standout feature is the embedded terminal: pressing Enter on a reply opens your editor inside the same pane, and you can run shell commands against a message without leaving. Gmail still requires OAuth — aerc supports the `oauthbearer` and `xoauth2` SASL mechanisms — so you supply a token in the IMAP source URL or, more commonly, an app password during setup.

```ini
# ~/.config/aerc/accounts.conf — Gmail with an app password
[Gmail]
source   = imaps://you%40gmail.com@imap.gmail.com:993
outgoing = smtps://you%40gmail.com@smtp.gmail.com:465
from     = You <you@gmail.com>

# For OAuth instead, append the SASL mechanism and a token:
# source = imaps+oauthbearer://you%40gmail.com@imap.gmail.com:993?token=...
```

## neomutt vs aerc vs an API-backed TUI

The two IMAP clients win on customization and ecosystem; an API-backed client wins on setup and provider auth. The table compares all three across the dimensions that decide which one survives on your machine past the first week. The muted columns are the classic clients; the emphasized column is the path that skips IMAP.

| Dimension | neomutt | aerc | nylas tui |
| --- | --- | --- | --- |
| First released | 2016 (mutt fork) | 2019 | 2024 |
| Transport | IMAP / SMTP | IMAP / JMAP / SMTP | Nylas API (HTTPS) |
| Gmail auth | App password / OAuth script | App password / OAuth script | OAuth (built in) |
| Loads large folder | Synchronous (can stall) | Asynchronous | Paged API calls |
| Config | One muttrc, hundreds of options | Three conf files | None (uses grants) |
| Scriptable output | No | Limited | `--json` on every command |

## How is an API-backed terminal client different?

`nylas tui` launches a k9s-style terminal interface with vim-style j/k navigation, but it reaches your mail through the Nylas API over HTTPS rather than IMAP. That single difference removes the two setup chores that sink IMAP clients: there's no server, port, or folder to configure, and there's no app password — you authenticate once with `nylas init` over OAuth and the token refreshes every 3,600 seconds.

The same grant powers both the interactive view and scripting. While neomutt and aerc keep mail inside the UI, every Nylas command also runs headless with `--json`, so the inbox you read in the TUI is the inbox a cron job or AI agent reads through `nylas email list`. The trade-off is honest: neomutt and aerc offer far deeper keyboard customization and offline Maildir workflows that an API client doesn't replace.

```bash
# Launch the interactive terminal UI (OAuth-backed, no IMAP config)
nylas tui

# The same account, read headless for scripts
nylas email list --json --limit 20 | jq -r '.[] | "\(.from[0].email)\t\(.subject)"'
```

Pick neomutt if you want a tinkerable, infinitely scriptable mail cockpit and don't mind the OAuth helper. Pick aerc for a modern async feel with multiple accounts. Reach for [the API-backed TUI](https://cli.nylas.com/guides/read-email-from-terminal) when the IMAP setup and app-password rotation cost more than the customization is worth. The [full CLI email tools comparison](https://cli.nylas.com/guides/best-cli-email-tools-compared) ranks the wider field.

## Next steps

- [Best CLI email tools compared](https://cli.nylas.com/guides/best-cli-email-tools-compared) — the wider field of terminal mail clients ranked
- [Read email from the terminal](https://cli.nylas.com/guides/read-email-from-terminal) — the `nylas tui` and `nylas email list` walkthrough
- [List Gmail emails from the CLI](https://cli.nylas.com/guides/list-gmail-emails) — Gmail without an IMAP app password
- [Gmail SMTP settings](https://cli.nylas.com/guides/gmail-smtp-settings) — the IMAP and SMTP values neomutt and aerc need
- [Full command reference](https://cli.nylas.com/docs/commands) — every flag and subcommand documented