config

config is a Rust crate for building layered application configuration: set defaults, load values from JSON, TOML, YAML, INI, RON, JSON5, or Corn files, override with environment variables, and finally apply explicit programmatic overrides — all merged into one queryable, loosely-typed configuration object. It’s designed around the 12-factor app pattern of layering config sources by precedence rather than committing to a single format.

Values can be read as any reasonably convertible type and accessed via a JSONPath-like dotted/subscript syntax (redis.port, databases[0].name), and the crate’s Format trait lets applications add support for custom or proprietary config formats without forking the library. It is a read-only configuration loader — it does not write changed values back to source files.

What You Get

• A ConfigBuilder for composing layered sources: defaults, files, environment variables, and explicit set() overrides, applied in a defined precedence order
• File format support behind feature flags: json, toml, yaml, ini, ron, json5, and corn
• Environment-variable source binding with configurable prefix/separator for 12-factor-style config
• JSONPath-subset value access supporting nested (redis.port) and indexed (databases[0].name) paths
• A Format trait extension point for adding custom or proprietary configuration formats
• serde-based deserialization into strongly-typed structs via config.try_deserialize::<T>()

Common Use Cases

• Loading a service’s configuration from a base file, an environment-specific override file, and environment variables in one merged view
• Building 12-factor-compliant applications where configuration precedence follows file defaults overridden by environment variables
• Deserializing merged configuration directly into a strongly-typed application settings struct via serde
• Adding a proprietary or uncommon configuration format to an existing app via the Format trait without switching config libraries

Under The Hood

Architecture - The crate is organized as a Cargo workspace with a layered-source model: builder.rs implements ConfigBuilder, which accumulates Source implementations (see source.rs) in precedence order; src/file/ handles file-based sources with per-format parsers dispatched through the Format trait in format.rs; src/env.rs implements the environment-variable source; src/path/ implements the JSONPath-subset traversal used for dotted/indexed value access; and config.rs ties builder output into the final queryable Config object, with de.rs/ser.rs providing serde (de)serialization and value.rs/map.rs the internal loosely-typed value representation.

Tech Stack - Built on serde for typed (de)serialization plus per-format parser crates gated behind feature flags (toml, serde_yaml-family, rust-ini, ron, json5, a Corn parser), so applications only compile in the parsers they actually use. The workspace targets Rust 2024 edition with MSRV 1.85.0, and enforces an extensive set of rust_2018_idioms and clippy lints workspace-wide, plus deny.toml/committed.toml/_typos.toml for dependency auditing, commit message linting, and typo checking in CI.

Code Quality - Testing is substantial: a tests/testsuite integration suite alongside numerous runnable examples/ (simple usage, async sources, custom string/file formats, priority layering, file watching), all exercised in CI. The project has 94 contributors, ~1,314 commits, and averages 8 commits/month, indicating active, ongoing maintenance rather than a stalled utility crate.

API Design - The primary flow — Config::builder().add_source(...).build() then .get::<T>("path") or .try_deserialize::<T>() — reads as a fluent builder pattern familiar to Rust developers, and the JSONPath-subset access syntax avoids requiring callers to define intermediate structs just to read one nested value. The examples/ directory doubles as executable documentation for less common flows like async sources and custom formats, lowering the cost of adopting advanced features.