How do I use Prost in a no_std embedded project?

Disable the std feature in Cargo.toml and configure prost-build to use BTreeMap for map fields. The README provides a detailed example for setting this up in build.rs.

Prost vs the official protobuf Rust library: which is better?

Prost is idiomatic and focused on correctness with Option types, but the official library might offer more features like runtime support. Check the protobuf-rust crate for current development status.

Can I skip installing protoc with Prost?

Yes, by enabling the skip_protoc option in prost-build, but this is not recommended as protoc is required for standard compilation since v0.11, and you might miss updates.

How does Prost handle optional fields in proto3?

Prost wraps scalar fields in Option types only if marked optional, but message fields are always Option, ensuring safety at the cost of verbosity, as explained in the FAQ.

Is Prost compatible with Serde for serialization?

Prost isn't a Serde serializer, but you can add Serde derives to generated types to support both formats, though mapping Protobuf tags to Serde is not straightforward.

What's the recursion limit in Prost and can I increase it?

The default recursion limit is 100 and cannot be customized; you can only disable it with the no-recursion-limit feature flag, which might risk stack overflows.

Open-Awesome

prost

Apache-2.0Rustv0.14.4

A Protocol Buffers implementation for Rust that generates simple, idiomatic Rust code from .proto files.

GitHub

4.8k stars651 forks0 contributors

What is prost?

Prost is a Protocol Buffers implementation for Rust that generates clean, idiomatic Rust code from .proto files. It focuses on correctness and simplicity by leveraging Rust's type system and derive attributes to produce readable types that accurately reflect Protobuf's optional field semantics.

Target Audience

Rust developers working with gRPC services, microservices, or any system requiring efficient serialization and data interchange using Protocol Buffers.

Value Proposition

Developers choose Prost for its idiomatic code generation that integrates seamlessly with Rust's ecosystem, its emphasis on safety through explicit Option types for optional fields, and its support for no_std environments, making it suitable for embedded systems.

Overview

PROST! a Protocol Buffers implementation for the Rust Language

Use Cases

Best For

Generating Rust types from .proto files for gRPC services in Rust projects.
Building no_std compatible applications that require Protocol Buffers serialization.
Serializing existing Rust types to Protobuf format using custom derive attributes.
Projects requiring comment preservation from .proto files in generated Rust code.
Implementing Protobuf-based communication in embedded systems or resource-constrained environments.
Ensuring correct handling of optional Protobuf fields through explicit Option types in Rust.

Not Ideal For

Projects requiring runtime reflection or dynamic Protobuf message inspection
Teams needing active feature development and frequent library updates
Environments where installing and managing external protoc is a significant burden
Applications relying on advanced Protobuf extensions or features not supported in the generated code

Pros & Cons

Pros

Idiomatic Code Generation

Generates clean, readable Rust types using derive attributes, as shown in the example where messages become structs with proper enums and modules.

Comment Preservation

Retains comments from .proto files in the generated Rust code, improving documentation without extra effort.

no_std Compatibility

Supports embedded systems with feature flags to disable std, allowing use in resource-constrained environments.

Existing Type Serialization

Enables serialization of custom Rust types via attributes, so you don't need to generate code for every data structure.

Cons

Missing Runtime Features

Lacks support for runtime reflection and message descriptors, limiting dynamic use cases like introspection or generic processing.

Passive Maintenance

Marked as passively-maintained with the maintainer not adding new features, which could lead to stagnation or slow bug fixes.

External protoc Dependency

Requires protoc to be installed separately for compilation from v0.11, adding setup complexity compared to bundled solutions.

Frequently Asked Questions

Related Projects

json

Strongly typed JSON library for Rust

Stars5,656

Forks689

Last commit7 days ago

rkyv

Zero-copy deserialization framework for Rust

Stars4,378

Forks239

Last commit28 days ago

https://github.com/ron-rs/ron

Rusty Object Notation

Stars4,036

Forks162

Last commit2 days ago

bincode

A binary encoder / decoder implementation in Rust.

Stars3,060

Forks309

Last commit1 year ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub