envelope is a modern environment variables manager.

You can install envelope from homebrew-core:

You can download the envelope binary in the latest release and copy the binary to a folder in your $PATH

You can install envelope with cargo, make sure that your ~/.cargo folder is in your $PATH

There is an aur package that packages the binary, called envelope-bin:

envelope is written in Rust, so you'll need the Rust compiler.

To build envelope:

envelope is a command line utility that leverages an SQLite database to keep track of your environment variables so you can easily switch between different configurations.

Initialize envelope in your project directory:

Import your existing .env file:

Export variables to your shell:

Verify which environment is active:

Initialize envelope in your current directory. This creates a .envelope database file.

Pipe .env files to envelope to get a pretty format representation of the file

Import from .env file

It's also possible to import directly from stdin

List all saved environments:

List environment variables of a particular environment:

Pretty print with a table format:

Truncate long values in pretty print mode:

Sorting Options

You can specify the sorting order using the --sort option:

• key or k: Sort by key in ascending order
• value or v: Sort by value in ascending order
• date or d: Sort by creation date in ascending order
• kd: Sort by key in descending order
• vd: Sort by value in descending order
• dd: Sort by creation date in descending order (default)

Example:

Add environment variables to an environment:

Variable names are automatically uppercased:

Read value from stdin for sensitive data:

Add a variable with an empty value:

Delete a specific variable from an environment:

Delete a variable across all environments:

Delete an entire environment:

Drops (hard deletes) an environment and permanently removes all its variables from the database:

Create a copy of an existing environment:

This is useful for:

• Creating a new environment based on an existing one
• Copying production settings to staging for testing
• Creating backups before making changes

Example workflow:

Open your $EDITOR to interactively edit environment variables:

This opens your default editor with all variables in the format:

Editing tips:

• Modify values by changing the text after =
• Delete a variable by commenting it out with #:
  #API_KEY=your_api_key

• Add new variables by adding new lines:
  NEW_VAR=new_value


When you save and close the editor, envelope will:

• Update all modified values
• Delete all commented variables (soft delete)
• Add all new variables

Check which environment(s) are currently exported in your shell:

Check works by comparing your current shell's environment variables against all stored environments. It will show all environments whose variables exactly match what's currently exported.

Multiple environments can match if they share the same variables:

If no environment matches completely, nothing is returned:

Encrypt the envelope database. You will be prompted for a password and a confirmation.

Decrypt the envelope database with the password you set when locking it.

Compare two environments to see their differences:

The output shows:

• Gray # lines: Variables present in both environments but with different values
  • First value is from the source environment (local)
  • Second value is from the target environment (prod)
• Red - lines: Variables only in the target environment (prod)
• Green + lines: Variables only in the source environment (local)

Use cases:

Revert a variable to its previous value. Each call to revert moves one step back in history:

Practical example:

Run a command with environment variables from a specific environment automatically injected. This avoids the need to manually export variables into your shell.

You can run any command and its arguments. The -- separator is optional but recommended when your command includes its own flags.

If you wish to clear the inherited envs from the parent process, you can use the --isolated flag and that will make sure only the selected env variables are injected in the subprocess.

Use cases:

• Run scripts without polluting your current shell environment.
• Quickly test different environments against the same command.
• Use in CI/CD pipelines to wrap execution steps.

View the complete history of a variable, including deleted values:

View deleted variables:

Use cases:

• Audit when and how a variable changed
• Find the previous value before a mistake
• Track configuration changes over time
• Recover deleted variables by seeing their last value

Add these to your .bashrc or .zshrc for faster workflows:

Always add .envelope to .gitignore:

The .envelope file is a SQLite database containing all your environment variables. This file should never be committed to version control as it contains sensitive data like:

• API keys and tokens
• Database passwords
• Secret keys
• OAuth credentials

Use encryption for sensitive projects:

Recommendations:

• Use --stdin flag when adding sensitive values to avoid shell history:
  $ envelope add prod secret_key --stdin
• Use envelope lock on shared machines or when committing other changes
• Keep separate environments for development, staging, and production
• Regularly audit your variables using envelope history
• Use envelope diff to ensure production configs don't leak into development

Envelope stores in the .envelope database:

• All environment variable keys and values
• Complete history of changes (even deleted values)
• Timestamps for all modifications

What's NOT stored:

• Your shell environment
• Files outside the current directory
• Git history or commits