awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
knadh avatar

knadh/koanf

0
View on GitHub↗

Koanf

koanf is a configuration management library for Go designed to load, merge, and unmarshal application settings from multiple sources into structured objects. It functions as a multi-source config loader that aggregates data from environment variables, files, and remote providers into a single unified map.

The system utilizes a pluggable architecture for parsing and data abstraction, allowing it to transform bytes from formats such as JSON, YAML, and TOML into nested maps. It supports dynamic configuration watching to monitor external sources and trigger automatic reloads when settings change.

The library provides tools for recursive map merging with custom collision resolution strategies and delimited key path querying for accessing nested values. It also includes capabilities for mapping configuration keys to strongly typed structs using custom tags and serializing configuration states back into raw bytes.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Features

  • Multi-Source Configuration - Aggregates configuration from files, environment variables, and CLI flags into a single unified object.
  • Configuration Aggregators - Aggregates configuration data from environment variables, files, and remote providers into a single unified map.
  • Configuration - Maps configuration keys to strongly typed Go structs using custom tags for easier access in application logic.
  • Map Merging - Combines nested configuration maps from multiple sources using recursive merging and custom collision strategies.
  • Direct Path Querying - Allows querying specific configuration values directly via delimited path expressions.
  • External Configuration Integration - Integrates application parameters with external configuration sources such as remote endpoints and files.
  • Configuration File Loading - Loads and parses settings from various structured files to determine application runtime behavior.
  • Delimited Path Lookups - Enables retrieval of deeply nested configuration values using delimited string paths.
  • Configuration Providers - Provides an extensible interface for fetching application settings from arbitrary external sources.
  • Configuration Formats - Supports multiple standardized data formats for organizing and defining application settings.
  • Byte-to-Map Parsers - Provides a pluggable interface to transform raw bytes from JSON, YAML, and TOML into structured maps.
  • Configuration File Parsers - Transforms bytes from formats such as JSON, YAML, and TOML into nested maps for application use.
  • Configuration Management Libraries - Provides a comprehensive Go library for loading, merging, and unmarshaling application settings from multiple sources.
  • Provider Abstractions - Decouples configuration data sources from the internal representation using a standardized provider interface.
  • Configuration Hot-Reloading - Updates application settings dynamically from monitored sources without requiring a service restart.
  • Configuration Merge Strategies - Provides custom functions to control how data from multiple configuration sources is merged.
  • Configuration Watchers - Monitors external configuration sources and triggers automatic reloads when settings are modified.
  • Event-Driven Callbacks - Implements event-driven callbacks to trigger configuration reloads when external sources are modified.
  • Struct Tags - Uses custom struct tags to map configuration keys directly to strongly typed Go struct fields.
  • Reflection-Based Unmarshallers - Uses reflection to map unstructured configuration data to typed Go structures.
  • Struct-Based Configurations - Maps configuration values into typed Go structs for safe input handling and access.
  • Configuration Change Watchers - Monitors configuration sources and triggers callbacks to automatically reload settings upon modification.
  • Configuration Management - Lightweight library for reading various config formats.
  • Configuration Management - Listed in the “Configuration Management” section of the Awesome Go awesome list.
  • Configuration Management - Lightweight configuration management library.
3,871 stars·183 forks·Go·mit·29 views

Star history

Star history chart for knadh/koanfStar history chart for knadh/koanf

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Frequently asked questions

What does knadh/koanf do?

koanf is a configuration management library for Go designed to load, merge, and unmarshal application settings from multiple sources into structured objects. It functions as a multi-source config loader that aggregates data from environment variables, files, and remote providers into a single unified map.

What are the main features of knadh/koanf?

The main features of knadh/koanf are: Multi-Source Configuration, Configuration Aggregators, Configuration, Map Merging, Direct Path Querying, External Configuration Integration, Configuration File Loading, Delimited Path Lookups.

Which projects share features with knadh/koanf?

Projects with overlapping indexed features include: spf13/viper — Viper is a configuration management library designed to centralize application settings from diverse sources into a… caarlos0/env — env is a Go library that reads environment variables and populates the fields of a Go struct according to tag… alecthomas/kong — Kong is a declarative command line interface framework and parser for Go. It maps flags and positional arguments… joho/godotenv — godotenv is a Go library designed to load, parse, and serialize environment configuration files. It provides tools to… kelseyhightower/envconfig — envconfig is a Go configuration decoder and environment variable mapper that deserializes environment variables into… dynaconf/dynaconf — Dynaconf is a configuration management library for Python applications that provides a unified system for loading,…

Projects sharing features with Koanf

These projects share indexed features with Koanf. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • spf13/viperspf13 avatar

    spf13/viper

    30,306View on GitHub↗

    Viper is a configuration management library designed to centralize application settings from diverse sources into a unified, type-safe registry. It aggregates data from local files, environment variables, command-line flags, and remote key-value stores, providing a single source of truth for application state. By utilizing a hierarchical key-value registry, the system resolves configuration values based on a prioritized stack of providers, ranging from default values to runtime overrides. The library distinguishes itself through its pluggable provider abstraction and dynamic update capabiliti

    Go
    View on GitHub↗30,306
  • caarlos0/envcaarlos0 avatar

    caarlos0/env

    6,004View on GitHub↗

    env is a Go library that reads environment variables and populates the fields of a Go struct according to tag directives. It uses reflection to iterate over struct types and tags at runtime, mapping environment variable names to struct fields and applying parsing behavior defined in struct tags. The library supports required field validation, returning errors when marked fields are missing or empty after parsing. It also provides default value fallback from struct tags when environment variables are not set, environment variable expansion that recursively substitutes references within values,

    Goconfigconfigurationenvironment
    View on GitHub↗6,004
  • alecthomas/kongalecthomas avatar

    alecthomas/kong

    2,976View on GitHub↗

    Kong is a declarative command line interface framework and parser for Go. It maps flags and positional arguments directly into typed Go structures using struct tags, allowing developers to define terminal interfaces through data models rather than manual parsing logic. The project functions as a configuration mapper that populates Go structures from a combination of command-line arguments, environment variables, and JSON files. It distinguishes itself by providing a dependency injection container to pass external services into command handlers and a plugin architecture for dynamic command reg

    Gocommand-linecommandsflags
    View on GitHub↗2,976
  • joho/godotenvjoho avatar

    joho/godotenv

    10,483View on GitHub↗

    godotenv is a Go library designed to load, parse, and serialize environment configuration files. It provides tools to extract configuration data from files into maps and inject those key-value pairs directly into the system environment of a Go application process. The project includes a configuration file serializer for exporting environment variable maps back into formatted files and a parser for extracting data without modifying the system environment. It supports injecting variables from strings or files into the process environment using priority-based overloading and overwriting. The li

    Godotenvenvironment-variablesgo
    View on GitHub↗10,483
Compare all 30 related projects→