Loads and parses .env-style key-value files with non-modifying and environment-modifying APIs, configurable loader, reader support, multiline/substitution handling, and compile-time/runtime loading options.
This is a Kotlin Multiplatform line-by-line transliteration port of allan2/dotenvy.
Original Project: This port is based on allan2/dotenvy. All design credit and project intent belong to the upstream authors; this repository is a faithful port to Kotlin Multiplatform with no behavioural changes intended.
This is an in-progress port. The goal is feature parity with the upstream Rust crate while providing a native Kotlin Multiplatform API. Every Kotlin file carries a // port-lint: source <path> header naming its upstream Rust counterpart so the AST-distance tool can track provenance.
allan2/dotenvyThe text below is reproduced and lightly edited from
https://github.com/allan2/dotenvy. It is the upstream project's own description and remains under the upstream authors' authorship; links have been rewritten to absolute upstream URLs so they continue to resolve from this repository.
A well-maintained fork of the dotenv crate.
This crate is the suggested alternative for dotenv in security advisory RUSTSEC-2021-0141.
The main branch contains the unpublished 0.16 version which is still subject to change. The contents of this README are for a version that is not yet published to crates.io. The current stable release is 0.15.7.
dotenvy - A well-maintained fork of the crate.An environment file, or env file, is a plain text file consisting of key-value pairs.
.env
HOST=foo
PORT=3000
Common names for env files are .env, .env.dev, .env.prod, but any name can be used. The default path for this crate is .env.
Variables can span multiple lines and can also be substituted. For an explanation of substituion rules, refer to the .env-substitution example file.
This library contains two APIs, a non-environment-modifying API and an environment-modifying API.
The non-modifying API is recommended for most use cases.
use dotenvy::{EnvLoader};
fn main() -> Result<(), Box<dyn std::error::Error>> {
let env_map = EnvLoader::new().load()?;
println!("HOST={}", env_map.var("HOST")?);
Ok(())
}
// from a file
let loader1 = EnvLoader::().(EnvSequence::InputThenEnv);
= EnvLoader::();
= ;
= EnvLoader::(Cursor::(s));
= EnvLoader::().(EnvSequence::EnvThenInput);
Loader constuction is infallible. When reading from a path, I/O is deferred until the load call.
This is to support configurations such as dev/prod and
optional loading.
There are situations where modifying the environment is necessary. For example, you may be spawning a child process that reads the environment.
dotenvy provides the load attribute macro for this purpose. To use it, enable the macros feature.
#[dotenvy::load]
#[tokio::main]
async fn main() {
println!("HOST={}", std::env::var("HOST").unwrap());
}
Because set_var is not thread-safe, the load attribute macro modifies the environment before the async runtime is started.
The expansion of this macro is here.
load is configurable. The default configuration expands to:
#[dotenvy::load(path = "./env", required = true, override_ = false)]
For more advanced usage, EnvLoader::load_and_modify can be used.
The dotenv! macro provided by dotenvy_macro crate can be used.
We aim to support the latest 8 rustc versions - approximately 1 year. Increasing MSRV is not considered a semver-breaking change.
The original dotenv crate has not been updated since June 26, 2020. Attempts to reach the authors and present maintainer were not successful (dotenv-rs/dotenv #74).
This fork intends to serve as the development home for the dotenv implementation in Rust.
This repo adds:
EnvLoaderio::ReadError type, containing the file path and variable nameFor a full list of changes, refer to the changelog.
Contributions are welcome! If you are thinking of contributing, please refer to CONTRIBUTING.md.
Legend has it that the Lost Maintainer will return, merging changes from dotenvy into dotenv with such thrust that all Cargo.tomls will lose one keystroke. Only then shall the Rust dotenv crateverse be united in true harmony.
Until then, this repo dutifully carries on the dotenv torch. It is actively maintained.
dependencies {
implementation("io.github.kotlinmania:dotenvy-kotlin:0.1.1")
}
./gradlew build
./gradlew test
See AGENTS.md and CLAUDE.md for translator discipline, port-lint header convention, and Rust → Kotlin idiom mapping.
This Kotlin port is distributed under the same MIT license as the upstream allan2/dotenvy. See LICENSE (and any sibling LICENSE-* / NOTICE files mirrored from upstream) for the full text.
Original work copyrighted by the dotenvy authors.
Kotlin port: Copyright (c) 2026 Sydney Renee and The Solace Project.
Thanks to the allan2/dotenvy maintainers and contributors for the original Rust implementation. This port reproduces their work in Kotlin Multiplatform; bug reports about upstream design or behavior should go to the upstream repository.
dotenvdotenvy_macro - A macro for compile-time .env inspection. This is a fork of dotenv_codegen.dotenvy-macros - A runtime macro library containing the load attribute macro.dotenvy binary that loads an env file before executing a specified command.load attribute macroSurfaced from shared tags and platforms — no rankings paid for.