The age Encryption Tool: Modern GPG Alternative

age (Actually Good Encryption) was designed by Filippo Valsorda and Ben Cartwright-Cox as a simple, modern alternative to GPG. The design rejects GPG's complexity: no key rings, no trust model, no key signing, no configuration files, no plugin ecosystem for core operations. age focuses on doing one thing well: encrypting and decrypting files in a straightforward, hard-to-misuse way.

The primary recipient type in age is an age public key, derived from X25519. age-keygen generates a key pair: an age public key (starting with age1) and an age identity file containing the private key. To encrypt to a recipient, specify their age public key with -r age1...; to decrypt, provide your identity file with -i key.txt. The format is designed to be copy-paste safe.

age can encrypt directly to SSH public keys, both RSA and Ed25519. If you have a recipient's SSH public key (from GitHub: curl https://github.com/username.keys), you can encrypt a file to them without any additional key exchange: age -r @recipient_public_key.txt plaintext.txt > encrypted.age. The recipient decrypts using their existing SSH private key identity.

age supports password-based (symmetric) encryption with the -p flag. It uses scrypt for key derivation from the passphrase, providing memory-hard resistance against brute force. This mode requires no key management: anyone with the passphrase can decrypt. It is suitable for cases where key distribution is impractical, such as encrypting backup archives stored in the cloud.

An age identity file contains the private key in text format, one key per line. Unlike GPG's binary keyring, identity files are plain text that can be stored anywhere, backed up, and managed with standard file tools. Protect identity files with filesystem permissions or encrypt them with a passphrase (using another age encryption layer or a tool like age-plugin-yubikey). Identity files are specified with -i on decryption.

age-keygen generates a new X25519 key pair in seconds: age-keygen -o key.txt. The output file contains the private key, and the corresponding public key is printed to stdout. There is no interactive configuration: key type, size, and algorithm are fixed. This simplicity means there are no generation options to misconfigure, and the output format is standardized and parseable.

age supports encrypting to multiple recipients in a single operation: age -r age1alice... -r age1bob... file.txt. Any of the listed recipients can decrypt the file independently using their own private key. Internally, age encrypts the symmetric file key separately to each recipient and stores all encrypted key copies in the header. This is conceptually similar to GPG's multi-recipient encryption.

rage is a Rust implementation of the age specification, offering the same file format and CLI interface. Rust's memory safety guarantees and performance make rage an attractive alternative to the reference Go implementation. Both implementations are interoperable: files encrypted with age can be decrypted with rage and vice versa. rage is available via package managers on most platforms.

age plugins extend the recipient types supported by age. age-plugin-yubikey enables encryption to YubiKey hardware security keys using the PIV interface, so decryption requires physical possession of the YubiKey. Plugins follow a standardized protocol, allowing new recipient types without modifying the core age binary. This extensibility supports hardware key support while keeping the base tool minimal.

age excels in simplicity: no trust model to manage, no key signing parties, no configuration, and a one-line encrypt or decrypt command. GPG has far more features: key signing, trust levels, key servers, multiple subkeys, photo IDs, and extensive integration with mail clients. For encrypting files and backups, age is often the better choice. For email encryption and software signing ecosystems, GPG remains standard.

age is particularly well-suited for automated backup encryption. A cron job can encrypt backups to a set of recipient public keys stored in a file: age --recipients-file recipients.txt backup.tar.gz > backup.tar.gz.age. No passphrase entry is needed, key management is simple, and multiple operators can decrypt independently using their own keys. The resulting files are resistant to server compromise.

Which of the following is NOT a supported recipient type in age encryption?

age recap: designed for simplicity over features, X25519-based age public keys for primary recipients, SSH public keys as convenient alternative recipients, scrypt-based password encryption for passphrase mode, age-keygen for key pair generation, multiple recipients in one file, rage as a Rust alternative with identical file format, plugins for hardware key support, and ideal for automated backup encryption pipelines.