tokio-rs/prost
Prost
Prost is a Protocol Buffers implementation for Rust that functions as a binary serialization framework and code generator. It translates schema definitions into idiomatic Rust structs and enums, providing the logic necessary to encode and decode structured data into the Protocol Buffers binary format.
The project distinguishes itself through a no-std implementation, allowing it to operate in embedded or kernel environments that lack a standard library. It also serves as a schema introspector by emitting file descriptor sets, which enables the programmatic analysis of original schema definitions at runtime.
The library covers a broad range of capabilities, including service trait generation for interface modeling, support for well-known types, and procedural macro annotations for mapping manual type definitions. It also provides tools for dependency management and fuzz testing to ensure serialization stability.
Features
- Protocol Buffers Serializers - Provides a high-performance implementation of Protocol Buffers serialization and deserialization for Rust.
- Binary Deserialization - Transforms binary streams back into structured Rust data objects through efficient deserialization.
- Binary Serialization Formats - Implements binary serialization and deserialization for efficient storage and transmission of structured data.
- Protobuf-to-Struct Generators - Translates Protocol Buffer schema files into idiomatic Rust structs and enums for type safety.
- Schema-Driven Code Generators - Translates Protocol Buffer definitions into idiomatic Rust structs and enums via a compiler-based process.
- Protobuf Code Generators - Automatically generates type-safe Rust source code and serialization logic from Protocol Buffer definitions.
- Embedded Communication Libraries - Provides optimized Protocol Buffer serialization for structured data exchange in resource-constrained embedded environments.
- No-Std Environment Adapters - Implements compatibility for environments without a standard library, enabling use in embedded or kernel contexts.
- Rust Code Generators - Generates idiomatic Rust structs and enums from schemas while preserving package organization and comments.
- Protocol Buffer Implementations - Provides a full implementation of the Protocol Buffers serialization logic, including encoding and decoding.
- Binary Descriptor Sets - Produces binary descriptor sets during build time to allow programmatic analysis of schemas at runtime.
- gRPC Service Implementations - Implements gRPC service definitions and generates the necessary Rust traits and data structures for RPC communication.
- No-Std Serialization Libraries - Offers a serialization implementation compatible with embedded or kernel environments that lack the Rust standard library.
- Procedural Macros - Utilizes Rust procedural macros to map manual type definitions to serialization logic without external schema files.
- Serialization Annotations - Supports adding serialization attributes and field tags to manual type definitions to avoid code generation.
- Service Contract Generators - Generates type-safe service contracts and communication layer code from abstract service definitions.
- Serialization Logic Generators - Automates the creation of encoding and decoding logic using procedural annotations for data mapping.
- Trait-Based Service Abstractions - Generates specialized Rust traits from service definitions to ensure consistent interface implementations.
Star history
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.
