1. What Is It and Why You Need It

The config crate in the Rust ecosystem is a powerful and flexible tool for managing application configuration. It provides a unified interface for loading settings from various sources: files (JSON, YAML, TOML, INI, HJSON), environment variables, command-line arguments, and even remote sources. The core purpose of this library is to abstract away the process of reading and merging configurations, letting you focus on business logic instead of format parsing.

Why does this matter in real-world projects? Modern applications rarely rely on a single configuration source. A typical scenario: base settings live in a config.toml file, sensitive data (passwords, API keys) comes from environment variables, and runtime-specific parameters are passed via command-line arguments. config lets you merge all these sources into a single settings tree with clear priority rules (e.g., environment variables override file values). Without this library, you'd have to manually write code for each source, handle parsing errors, and track override order.

Key advantages of config: full type safety (settings deserialize into Rust structs), support for nested configurations, automatic file change detection (watch), and extensibility through custom data sources. The crate is widely used in production projects like web servers, CLI tools, and microservices.

2. Installation

To add the config crate to your Rust project, use the Cargo package manager. Run this command in your project's root directory:

cargo add config

If you prefer editing Cargo.toml manually, add this to the [dependencies] section:

[dependencies]
config = "0.14"

You'll also need a serialization/deserialization crate. serde with the derive macro is recommended:

cargo add serde --features derive

To work with specific file formats, add the corresponding feature flags. For example, to support TOML, YAML, and JSON:

cargo add config --features yaml,json,toml

Available formats: ini, json, toml, yaml, hjson. If you only need one format, specify just that — it will reduce compilation time.

3. Quick Start — Minimal Working Example

Create a Settings.toml file in your project root:

# Settings.toml
[server]
host = "127.0.0.1"
port = 8080

[database]
url = "postgres://user:pass@localhost/db"
pool_size = 10

Now let's write the code to read this configuration:

use config::{Config, File, FileFormat};
use serde::Deserialize;
use std::env;

#[derive(Debug, Deserialize)]
struct ServerConfig {
    host: String,
    port: u16,
}

#[derive(Debug, Deserialize)]
struct DatabaseConfig {
    url: String,
    pool_size: u32,
}

#[derive(Debug, Deserialize)]
struct AppConfig {
    server: ServerConfig,
    database: DatabaseConfig,
}

fn main() -> Result<(), config::ConfigError> {
    // Create a config builder
    let builder = Config::builder()
        // Add a file as a source
        .add_source