Open-source alternatives to Mapstructure

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,

This is a configuration library for JVM applications that parses HOCON, JSON, and Java properties files into an immutable tree structure. It resolves ${...} placeholders by traversing the configuration tree and falling back to environment variables and system properties, and validates loaded configurations against a reference schema. The library loads configuration from classpath resources, files, URLs, system properties, and environment variables, merging them with priority-based override semantics. It provides typed value access with automatic type coercion, supports dot-path navigation,

This project is a data validation framework for the Go programming language that enforces integrity by applying declarative constraints to struct fields. It utilizes reflection to inspect data structures at runtime, mapping field-level requirements defined in struct tags to specific validation logic. The library distinguishes itself through its ability to handle complex object graphs by recursively traversing nested structures and slices. It supports context-aware validation, allowing developers to switch between different rule sets for the same data structure based on application state or sp

go-funk is a functional programming library for Go that provides a set of helper functions to transform and query slices and maps. It enables a declarative coding style for collection manipulation and data transformation, reducing the need for repetitive manual loops. The library implements higher-order functions for common operations, including mapping, filtering, and searching through data structures using predicates and callbacks. It includes utilities for detecting element existence and finding common elements between collections. These capabilities are supported through generic-based ty

yargs is a command-line interface framework and argument parser for Node.js. It translates raw command-line strings into structured JavaScript objects, providing a toolkit for building terminal applications with nested sub-commands, dedicated handlers, and a structured user interface. The framework distinguishes itself through automated help text generation, which constructs formatted usage menus and instructions based on registered metadata. It also provides shell completion generation for Bash and Zsh and uses string-distance algorithms to offer typo correction suggestions when invalid inpu

Gson is a Java library designed for the serialization and deserialization of objects into structured text formats. It functions as a reflection-based data mapper, inspecting class structures at runtime to automatically convert memory-resident objects into data representations and reconstruct them back into typed language objects. The library distinguishes itself through a modular type-adapter pattern that allows for custom conversion rules for complex or nested structures. It also provides robust support for production environments by generating build-time metadata and configuration rules, wh

Copier is a Go library that deep copies data between structs, maps, and slices using reflection-based field mapping and struct tag controls. At its core, it automatically transfers values by matching source and destination fields by name, type, and methods, creating fully independent copies of nested data structures to prevent shared references and unintended mutations. The library distinguishes itself through tag-driven copy rules that give developers fine-grained control over the copying process. Struct tags can enforce mandatory field copying, exclude specific fields from transfer, or map

Colfer is a binary serialization format optimized for speed and size.

Bond was a cross-platform framework for working with schematized data. The open-source project ended on March 31, 2025.

Protocol Buffers is a language-neutral, platform-agnostic mechanism for serializing structured data. It provides a schema-driven toolchain that compiles declarative data definitions into type-safe source code, enabling consistent communication and strongly typed API contracts across services written in different programming languages. The project distinguishes itself through a highly efficient binary wire format that utilizes tag-based encoding and variable-width integer compression to minimize payload size and processing overhead. It supports robust evolutionary schema management, allowing d

idiomatic codec and rpc lib for msgpack, cbor, json, etc. msgpack.orgGo

This project is a Protocol Buffers implementation for Go, providing a binary serialization framework to convert native data structures into a compact binary format for efficient network transmission and storage. It functions as a language bindings generator, utilizing a compiler plugin to create Go source code from platform-neutral protocol buffer definitions. The implementation includes a JSON data mapper that transforms structured binary messages into JSON format to facilitate compatibility with web services and external APIs. It also enables cross-language data exchange by using a common s

FlatBuffers is a cross-platform serialization library designed for performance-critical applications that require efficient, zero-copy data access. By organizing data in a structured binary format, it allows applications to read and write complex data structures directly from memory-mapped buffers without the need for intermediate parsing or temporary object allocation. The project distinguishes itself through a schema-driven approach that balances high-performance access with long-term data evolution. It utilizes a unique memory layout featuring relative offsets and inline fixed-size structu

csvutil provides fast and idiomatic mapping between CSV and Go (golang) values.

This project is a Protocol Buffers Go compiler and code generation framework that translates schema definitions into optimized Go structures and reflection-free serialization methods. It includes a gRPC service generator for producing client and server communication code and a serialization performance toolkit for generating automated benchmarks and test suites. The framework features a plugin-based system for transforming data definitions into source code with custom field mapping and struct tag injection. It allows for custom type mapping and struct type overriding to link data fields to sp

Marshmallow is a Python data serialization library and validation framework. It functions as a bridge that transforms complex application objects into primitive data types for storage or network transmission and vice versa. The library utilizes a schema-based approach to validate that incoming data conforms to specific types and constraints. It employs a two-way transformation pipeline consisting of separate load and dump phases to handle deserialization and serialization. The framework supports class-based schema definitions with declarative field validation and recursive schema nesting for

This project is a high-performance JSON library for Go, serving as a replacement for the standard encoding/json package. It provides a serialization engine for encoding and decoding data structures, alongside a schemaless parser for extracting specific values from JSON blobs using paths. The library distinguishes itself through a focus on reducing CPU and memory overhead. It implements a high-performance encoder that utilizes buffer reuse and reduced float precision to increase data throughput. Broad capability areas include data serialization, high-performance JSON processing, and schema-le

Python wrapper around rapidjson

Newtonsoft.Json is a data processing utility for the .NET ecosystem designed to facilitate the transformation and exchange of information. It functions as a serialization library and object mapping framework, enabling the conversion of complex application objects into formatted JSON strings and the reconstruction of structured objects from raw JSON data. The library distinguishes itself through a flexible architecture that supports both strongly-typed class mapping and a dynamic object model for schema-less data manipulation. It employs reflection-based metadata mapping to automate property a