# serde-rs/serde

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/serde-rs-serde).**

10,457 stars · 888 forks · Rust · apache-2.0

## Links

- GitHub: https://github.com/serde-rs/serde
- Homepage: https://serde.rs/
- awesome-repositories: https://awesome-repositories.com/repository/serde-rs-serde.md

## Topics

`derive` `no-std` `rust` `serde`

## Description

This project is a framework for the efficient serialization and deserialization of data structures. It provides a unified, macro-based interface that automates the conversion of complex internal objects into standardized formats and reconstructs them from raw input streams or buffers. By leveraging compile-time code generation, the library minimizes manual implementation overhead while ensuring consistent logic across diverse data types.

The framework distinguishes itself through a format-agnostic data model and a visitor-based parsing architecture that decouples data structures from specific output representations. It supports high-performance processing through incremental streaming, which allows for transcoding large datasets without loading them entirely into memory, and zero-copy data borrowing, which maps input data directly to memory references to avoid unnecessary allocations. These capabilities enable the library to operate effectively in both standard and memory-constrained environments.

Beyond core conversion, the project offers extensive configuration for schema management and structural mapping. Users can define custom serialization rules, override default trait bounds, and implement granular control over field filtering, default value population, and variant representation. The system also supports the integration of third-party types and provides robust error reporting to facilitate reliable data exchange across various systems and services.

## Tags

### Data & Databases

- [Rust](https://awesome-repositories.com/f/data-databases/serialization-frameworks/rust.md) — Provides a unified, macro-based interface for efficiently serializing and deserializing Rust data structures into various formats.
- [Data Conversion Tools](https://awesome-repositories.com/f/data-databases/data-conversion-tools.md) — Provides a unified framework for transforming complex internal objects into standardized formats and reconstructing them from raw input.
- [Data Serialization](https://awesome-repositories.com/f/data-databases/data-processing-pipelines/data-serialization.md) — Translates complex internal objects into standardized formats for seamless data exchange. ([source](https://serde.rs/data-model.html))
- [Data Serialization Frameworks](https://awesome-repositories.com/f/data-databases/data-serialization-frameworks.md) — Provides a unified, macro-based framework for serializing and deserializing complex data structures.
- [Zero-Copy Deserialization](https://awesome-repositories.com/f/data-databases/zero-copy-data-access-libraries/zero-copy-deserialization.md) — Borrows data directly from the input source during deserialization to reduce memory usage and improve processing speed. ([source](https://serde.rs/field-attrs.html))
- [Incremental Deserializers](https://awesome-repositories.com/f/data-databases/data-processing-pipelines/stream-processing-systems/stream-processing/incremental-deserializers.md) — Processes sequences of data elements one by one during deserialization to compute results without buffering the entire collection. ([source](https://serde.rs/stream-array.html))
- [Data Serialization and Parsing](https://awesome-repositories.com/f/data-databases/data-serialization-and-parsing.md) — Enables reading data from various sources to reconstruct complex objects using a unified interface. ([source](https://serde.rs/conventions.html))
- [Deserialization Engines](https://awesome-repositories.com/f/data-databases/data-serialization-formats/deserialization-engines.md) — Parses external data streams into native objects using a unified deserialization interface. ([source](https://cdn.jsdelivr.net/gh/serde-rs/serde@master/README.md))
- [Data Transcoders](https://awesome-repositories.com/f/data-databases/data-transcoders.md) — Streams data directly between different formats without loading entire datasets into memory.
- [Enum Tagging Configurators](https://awesome-repositories.com/f/data-databases/enum-definitions/enum-tagging-configurators.md) — Allows defining how enum variants are tagged in serialized output to match external requirements. ([source](https://serde.rs/container-attrs.html))
- [Large Dataset Streaming](https://awesome-repositories.com/f/data-databases/incremental-data-streaming/large-dataset-streaming.md) — Streams input data incrementally during deserialization to handle massive files without loading the entire structure into memory. ([source](https://serde.rs/examples.html))
- [Default Value Imputers](https://awesome-repositories.com/f/data-databases/missing-data-imputation/default-value-imputers.md) — Automatically populates missing fields with default values during the deserialization process. ([source](https://serde.rs/attr-default.html))
- [Naming Conventions](https://awesome-repositories.com/f/data-databases/naming-conventions.md) — Provides flexible field renaming and aliasing during serialization and deserialization to match external data schemas. ([source](https://serde.rs/field-attrs.html))
- [Strict Schema Enforcers](https://awesome-repositories.com/f/data-databases/schema-enforcement-tools/strict-schema-enforcers.md) — Rejects input containing unknown fields to ensure strict schema conformance. ([source](https://serde.rs/container-attrs.html))
- [Serialization Libraries](https://awesome-repositories.com/f/data-databases/serialization-libraries.md) — Implements manual serialization and deserialization logic for complex data structures. ([source](https://serde.rs/custom-serialization.html))
- [Zero-Copy Data Access](https://awesome-repositories.com/f/data-databases/zero-copy-data-access.md) — Supports zero-copy data borrowing to map input data directly to memory references, avoiding unnecessary allocations.
- [Binary Serialization](https://awesome-repositories.com/f/data-databases/binary-serialization.md) — Handles byte arrays through specialized methods for compact binary data storage. ([source](https://serde.rs/impl-serialize.html))
- [Embedded Serialization Utilities](https://awesome-repositories.com/f/data-databases/data-serialization-libraries/embedded-serialization-utilities.md) — Enables efficient serialization in memory-constrained environments without requiring a standard library.
- [Incremental Data Streaming](https://awesome-repositories.com/f/data-databases/incremental-data-streaming.md) — Enables incremental data transcoding to process large datasets without loading them entirely into memory.
- [JSON Serialization Libraries](https://awesome-repositories.com/f/data-databases/json-serialization-libraries.md) — Maps internal structs and enums to JSON objects using standardized naming and variant conventions. ([source](https://serde.rs/json.html))
- [Polymorphic Deserialization](https://awesome-repositories.com/f/data-databases/polymorphic-data-modeling/polymorphic-deserialization.md) — Parses input that may arrive as either a simple string or a complex object into a single unified data structure. ([source](https://serde.rs/string-or-struct.html))
- [Polymorphic Mapping](https://awesome-repositories.com/f/data-databases/polymorphic-mapping.md) — Maps variant-based types to different structural representations like tagged or untagged formats to ensure compatibility with diverse schemas. ([source](https://serde.rs/examples.html))
- [Complex Data Serialization](https://awesome-repositories.com/f/data-databases/complex-data-serialization.md) — Maps complex objects into standardized data models by implementing custom serialization logic. ([source](https://serde.rs/impl-serialize.html))
- [Data Standardization](https://awesome-repositories.com/f/data-databases/data-governance-modeling/data-standardization.md) — Provides a unified interface for transforming objects into standardized formats across various sources. ([source](https://serde.rs/data-model.html))
- [Field Exclusion Logic](https://awesome-repositories.com/f/data-databases/data-query-filters/field-exclusion-logic.md) — Excludes specific fields from serialization based on static rules or conditional logic. ([source](https://serde.rs/field-attrs.html))
- [Catch-All Variant Mappers](https://awesome-repositories.com/f/data-databases/enum-definitions/enum-label-mappings/catch-all-variant-mappers.md) — Maps unrecognized input values to a designated catch-all variant during deserialization. ([source](https://serde.rs/variant-attrs.html))
- [Numeric Representations](https://awesome-repositories.com/f/data-databases/enum-definitions/enum-label-mappings/numeric-representations.md) — Maps enumeration variants to their underlying numeric values during serialization instead of using string names. ([source](https://serde.rs/enum-number.html))
- [Automatic Field Population](https://awesome-repositories.com/f/data-databases/field-validation/automatic-field-population.md) — Automatically populates missing fields during deserialization using default values or factory functions. ([source](https://serde.rs/container-attrs.html))
- [Unmapped Field Collectors](https://awesome-repositories.com/f/data-databases/field-validation/unmapped-field-collectors.md) — Collects unknown key-value pairs into a designated map field to preserve data. ([source](https://serde.rs/attr-flatten.html))
- [Flattening Utilities](https://awesome-repositories.com/f/data-databases/map-data-structure-manipulation/flattening-utilities.md) — Simplifies data structures by merging nested fields into parent containers during the serialization process. ([source](https://serde.rs/field-attrs.html))
- [Remote Type Converters](https://awesome-repositories.com/f/data-databases/type-mapping-utilities/type-mapping-converters/remote-type-converters.md) — Enables serialization and deserialization for external types that do not natively implement conversion interfaces. ([source](https://serde.rs/container-attrs.html))
- [Shadow Type Mappers](https://awesome-repositories.com/f/data-databases/type-mapping-utilities/type-mapping-converters/shadow-type-mappers.md) — Enables data conversion for third-party types by providing local shadow definitions. ([source](https://serde.rs/remote-derive.html))
- [Field Format Overrides](https://awesome-repositories.com/f/data-databases/custom-data-fields/field-format-overrides.md) — Provides granular control to override default serialization logic for specific fields, such as custom date formatting. ([source](https://serde.rs/custom-date-format.html))
- [Serialization Format Mappings](https://awesome-repositories.com/f/data-databases/custom-data-types/serialization-format-mappings.md) — Maps internal data structures to specific output representations through custom method implementations. ([source](https://serde.rs/impl-deserializer.html))
- [Deserialization Discarding](https://awesome-repositories.com/f/data-databases/data-validation-libraries/deserialization-discarding.md) — Improves performance by ignoring incoming data during deserialization without storing it in memory. ([source](https://serde.rs/ignored-any.html))
- [Transparent Wrappers](https://awesome-repositories.com/f/data-databases/type-mapping-utilities/type-mapping-converters/transparent-wrappers.md) — Serializes and deserializes wrapper types as if they were the underlying inner type, omitting the wrapper structure from the output. ([source](https://serde.rs/container-attrs.html))
- [Deserialization Visitors](https://awesome-repositories.com/f/data-databases/visitor-data-apis/deserialization-visitors.md) — Uses visitor patterns to interpret input data and construct specific native types during deserialization. ([source](https://serde.rs/impl-deserialize.html))
- [Deserialization Visitors](https://awesome-repositories.com/f/data-databases/visitor-data-apis/visitor-data-integration/deserialization-visitors.md) — Implements a visitor-based parsing architecture to reconstruct complex objects from input streams.

### Software Engineering & Architecture

- [Compile-Time Code Generation](https://awesome-repositories.com/f/software-engineering-architecture/compile-time-code-generation.md) — Automates the generation of serialization and deserialization logic at compile time using procedural macros.
- [Variant Mappings](https://awesome-repositories.com/f/software-engineering-architecture/content-schemas/schema-variants/variant-mappings.md) — Allows granular control over how enum variants are named and represented during serialization to match external requirements. ([source](https://serde.rs/variant-attrs.html))
- [Intermediate Representations](https://awesome-repositories.com/f/software-engineering-architecture/data-formats/intermediate-representations.md) — Provides a format-agnostic intermediate representation to decouple data structures from specific output formats.
- [Data Serialization Formats](https://awesome-repositories.com/f/software-engineering-architecture/data-serialization-formats.md) — Converts data between different formats by streaming input directly to an output serializer without loading the entire dataset into memory. ([source](https://serde.rs/examples.html))
- [Custom Deserializers](https://awesome-repositories.com/f/software-engineering-architecture/configuration-deserializers/custom-deserializers.md) — Implements visitor patterns to control the parsing of complex data structures into native objects. ([source](https://serde.rs/deserialize-map.html))
- [Serialization Error Reporters](https://awesome-repositories.com/f/software-engineering-architecture/error-handling/parse-error-reporters/serialization-error-reporters.md) — Propagates failures during data conversion by returning standard result types. ([source](https://serde.rs/error-handling.html))
- [Serialization Naming Overrides](https://awesome-repositories.com/f/software-engineering-architecture/naming-conventions/serialization-naming-overrides.md) — Overrides default naming of types, fields, or variants to match external naming conventions. ([source](https://serde.rs/container-attrs.html))
- [Optional Value Serializers](https://awesome-repositories.com/f/software-engineering-architecture/optional-value-types/optional-value-serializers.md) — Serializes optional data by treating presence and absence as distinct states. ([source](https://serde.rs/impl-serialize.html))
- [Serialization Logic Generators](https://awesome-repositories.com/f/software-engineering-architecture/schema-generators/procedural-macro-generators/serialization-logic-generators.md) — Generates serialization and deserialization logic automatically using macros for consistent performance. ([source](https://serde.rs/no-std.html))
- [Generic Data Abstractions](https://awesome-repositories.com/f/software-engineering-architecture/abstract-data-types/generic-data-abstractions.md) — Uses trait-based interfaces to decouple data structures from specific serialization backends.
- [Flattening](https://awesome-repositories.com/f/software-engineering-architecture/content-schemas/schema-variants/variant-mappings/flattening.md) — The library serializes or deserializes variants without including their name or tag to integrate with untagged data formats. ([source](https://serde.rs/variant-attrs.html))
- [Format Error Translators](https://awesome-repositories.com/f/software-engineering-architecture/error-handling/format-error-translators.md) — Translates error types between different serialization formats to allow unified processing. ([source](https://serde.rs/convert-error.html))
- [Deserialization Generators](https://awesome-repositories.com/f/software-engineering-architecture/schema-generators/procedural-macro-generators/deserialization-generators.md) — Automates the creation of deserialization logic by applying macros to structs and enums. ([source](https://serde.rs/derive.html))
- [Serialization Generators](https://awesome-repositories.com/f/software-engineering-architecture/schema-generators/procedural-macro-generators/serialization-generators.md) — Automates the creation of serialization logic by applying macros to structs and enums. ([source](https://serde.rs/derive.html))
- [Code Generators](https://awesome-repositories.com/f/software-engineering-architecture/code-generators.md) — Automates the generation of conversion code to reduce manual implementation effort during the application lifecycle. ([source](https://serde.rs/feature-flags.html))
- [Enum Tagging Strategies](https://awesome-repositories.com/f/software-engineering-architecture/data-serialization-formats/enum-tagging-strategies.md) — Supports different tagging strategies for enum variants to define how identifiers are stored. ([source](https://serde.rs/enum-representations.html))
- [Inlining](https://awesome-repositories.com/f/software-engineering-architecture/inline-data-structures/inlining.md) — The library merges fields from a nested object directly into the parent structure during serialization and deserialization to simplify data modeling and reuse common field groups. ([source](https://serde.rs/attr-flatten.html))

### Web Development

- [Generic Mapping Systems](https://awesome-repositories.com/f/web-development/data-mapping/generic-mapping-systems.md) — Automates the conversion of structs and enums into diverse data representations while supporting custom logic and schema constraints.
- [Data Serializers](https://awesome-repositories.com/f/web-development/data-serializers.md) — Converts complex objects to and from various formats using generic interfaces. ([source](https://serde.rs/examples.html))
- [Serialization Defaults](https://awesome-repositories.com/f/web-development/serialization-defaults.md) — Provides context-aware default values for missing fields during data serialization and deserialization. ([source](https://serde.rs/field-attrs.html))
- [Variant Serialization Overrides](https://awesome-repositories.com/f/web-development/serialization-hooks/variant-serialization-overrides.md) — Allows custom logic for converting complex enum variants that require behavior beyond standard automated processes. ([source](https://serde.rs/variant-attrs.html))
- [Declarative Serialization Mappings](https://awesome-repositories.com/f/web-development/declarative-serializers/declarative-serialization-mappings.md) — Modifies serialization behavior using declarative rules applied to fields and containers. ([source](https://serde.rs/attributes.html))

### Operating Systems & Systems Programming

- [No-Std Environment Adapters](https://awesome-repositories.com/f/operating-systems-systems-programming/platform-development-integration/platform-support/environment-support-managers/no-std-environment-adapters.md) — Operates in environments without a standard library by disabling default features. ([source](https://serde.rs/no-std.html))
- [Dynamic Memory Allocation](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation.md) — Enables serialization and deserialization for heap-allocated types in environments without a full standard library. ([source](https://serde.rs/feature-flags.html))
- [Heap Collection Integrators](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/memory-allocation-tracers/heap-allocation-strategies/heap-collection-integrators.md) — Integrates support for heap-allocated data structures in memory-constrained environments. ([source](https://serde.rs/no-std.html))

### Programming Languages & Runtimes

- [External Trait Implementers](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/language-extensions/trait-implementations/external-trait-implementers.md) — Adds serialization capabilities to types defined in third-party libraries. ([source](https://serde.rs/examples.html))
- [Reference Counted Pointer Serializers](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/ownership-borrowing/reference-counting/reference-counted-pointer-serializers.md) — Enables serialization and deserialization for shared ownership pointers. ([source](https://serde.rs/feature-flags.html))
- [Standard Library Type Serializers](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/standard-libraries/standard-library-type-serializers.md) — Enables serialization and deserialization for common collections and types provided by the standard library. ([source](https://serde.rs/feature-flags.html))

### Development Tools & Productivity

- [Schema-Driven Code Generators](https://awesome-repositories.com/f/development-tools-productivity/project-scaffolding-config-code-generation/code-generation/schema-driven-code-generators.md) — Uses metadata annotations to automate the creation of conversion code for custom data structures. ([source](https://serde.rs/))