age is a simple, modern and secure file encryption tool, file format and Go library. It encrypts files to small, explicit keys — no keyring, no key server, no configuration files and no long option lists — and composes cleanly with the tools you already use on the command line. age was designed by Filippo Valsorda (@FiloSottile) and Ben Cartwright-Cox (@benjojo), and the format is published as an open specification.

Key Features

• Small explicit keys — a recipient is a short, copy-pasteable string such as age1ql3z7hjy54pw3hyww5ayyfg7zqgvc7w3j2elw8zmrj2kg5sfn9aqmcac8p. No key servers, no web of trust, no trust-on-first-use surprises.
• No configuration options — one binary, one man page. age deliberately refuses to grow a config file or a plugin-specific option soup, which keeps the attack surface and the mental model small.
• Modern cryptography — X25519 key agreement with ChaCha20-Poly1305 authenticated encryption for the default recipient mode, and scrypt plus ChaCha20-Poly1305 for passphrase-encrypted files.
• Post-quantum support — since age v1.3.0, age-keygen can generate hybrid post-quantum recipients (age1pq1…) and identities (AGE-SECRET-KEY-PQ-1…) that stay secure against future quantum computers.
• Passphrase mode — -p/--passphrase encrypts with a passphrase, auto-generating a strong diceware-style one when you leave the prompt empty. Passphrase-protected files are detected automatically at decrypt time.
• SSH keys as recipients — encrypt to an existing ssh-ed25519 or ssh-rsa public key and decrypt with the matching private key, so you can reuse keys you already manage.
• Streaming and UNIX-style composability — age reads stdin and writes stdout, so it slots straight into pipes: tar cvz ~/data | age -r age1… > backup.tar.gz.age.
• ASCII armor — --armor produces a PEM-style -----BEGIN AGE ENCRYPTED FILE----- block that survives email, chat and clipboard round-trips.
• Multiple recipients — repeat -r for each recipient, or keep a list in a file and pass it with -R, so a whole team can decrypt the same archive.
• Extensible through plugins — hardware PIV tokens such as YubiKeys are supported via age-plugin-yubikey, and post-quantum support is also available to older versions through age-plugin-pq.
• Open, specified and interoperable — the format is specified at age-encryption.org/v1; independent implementations exist in Rust (rage), TypeScript (Typage) and more, and files written by one implementation decrypt with another.
• Widely packaged — available in Debian, Ubuntu, Fedora, Arch, Alpine, Homebrew, MacPorts, winget and as signed static release binaries, with a reproducible build and release proofs.

Why Use age?

Traditional file encryption tooling forces a choice between tools that are hard to use correctly (raw OpenSSL or GnuPG command lines, keyring management, expiry and trust models) and proprietary black boxes. age takes the opposite approach: the defaults are safe, the keys are short strings you can paste into a chat message, and there is nothing to configure — so there is much less to get wrong. It is opinionated about cryptography rather than about workflow, which means it drops cleanly into shell scripts, backup jobs and CI pipelines without a wrapper.

It is also a good fit for teams already using SSH keys or hardware tokens: you can encrypt to a colleague’s existing ssh-ed25519 key and to a YubiKey-backed plugin recipient in the same file. Because the format is a public specification with multiple independent implementations, your encrypted data is not locked to one vendor or one language ecosystem.

Use Cases

• Encrypting backups and archives — pipe a tarball straight into age and keep the result in object storage or on a USB disk; decrypt with the private identity only when needed.
• Sharing secrets with a team — encrypt a config or credential file to several recipients (-R recipients.txt) and distribute the ciphertext over untrusted channels.
• Passphrase-protected single files — hand a password-protected archive to someone who has no key pair yet, using age -p and an auto-generated strong passphrase.
• Encrypting secrets for version control — age is the default and most-used backend for SOPS, which encrypts only the values in YAML/JSON/ENV files so the structure stays reviewable in git.
• Hardware-backed encryption — use age-plugin-yubikey so the decryption key never leaves a PIV token, or generate a post-quantum hybrid identity for long-term archives.
• Building encryption into an application — use age as a Go library (filippo.io/age) to add modern, well-reviewed file encryption to your own tooling without inventing a format.
• Scripted automation — encrypt in one process, decrypt in another, with error codes and no interactive prompts when a passphrase is not used.

Platforms

Linux (amd64, arm, arm64) · macOS (Intel and Apple silicon) · Windows (amd64, arm64) · FreeBSD. Also installed through Homebrew, MacPorts, winget, apk, pacman, apt, dnf, portage and Nix; the Go library is cross-platform by nature.

Licence

BSD-3-Clause — a permissive free and open source licence (Copyright 2019 The age Authors, 2019 Google LLC, 2022 Filippo Valsorda). Verified from the repository’s LICENSE file.

Website

github.com/FiloSottile/age · format specification: age-encryption.org/v1 · more tools and integrations: awesome age