#protobuf #serialization #json #file-descriptor #descriptor-set


A utility function for use with prost-build and prost-reflect to generate ReflectMessage implementations

9 releases (breaking)

0.13.0 Feb 7, 2024
0.12.0 Sep 1, 2023
0.11.0 Mar 27, 2023
0.9.0 Jul 30, 2022
0.6.0 Mar 14, 2022

#1344 in Encoding

Download history 1145/week @ 2023-12-24 1120/week @ 2023-12-31 1422/week @ 2024-01-07 1907/week @ 2024-01-14 2265/week @ 2024-01-21 1913/week @ 2024-01-28 1902/week @ 2024-02-04 2228/week @ 2024-02-11 2007/week @ 2024-02-18 2774/week @ 2024-02-25 2051/week @ 2024-03-03 2634/week @ 2024-03-10 2603/week @ 2024-03-17 3195/week @ 2024-03-24 3576/week @ 2024-03-31 2846/week @ 2024-04-07

12,365 downloads per month
Used in 7 crates (2 directly)


12K SLoC

crates.io docs.rs deps.rs MSRV Continuous integration codecov.io Apache 2.0 OR MIT licensed


A protobuf library extending prost with reflection support and dynamic messages.


This crate provides support for dynamic protobuf messages. These are useful when the protobuf type definition is not known ahead of time.

The main entry points into the API of this crate are:

Example - decoding

DynamicMessage does not implement Default since it needs a message descriptor to function. To decode a protobuf byte stream into an instance of this type, use DynamicMessage::decode to create a default value for the MessageDescriptor instance and merge into it:

use prost::Message;
use prost_types::FileDescriptorSet;
use prost_reflect::{DynamicMessage, DescriptorPool, Value};

let pool = DescriptorPool::decode(include_bytes!("file_descriptor_set.bin").as_ref()).unwrap();
let message_descriptor = pool.get_message_by_name("package.MyMessage").unwrap();

let dynamic_message = DynamicMessage::decode(message_descriptor, b"\x08\x96\x01".as_ref()).unwrap();

assert_eq!(dynamic_message.get_field_by_name("foo").unwrap().as_ref(), &Value::I32(150));

Example - JSON mapping

When the serde feature is enabled, DynamicMessage can be deserialized to and from the canonical JSON mapping defined for protobuf messages.

use prost::Message;
use prost_reflect::{DynamicMessage, DescriptorPool, Value};
use serde_json::de::Deserializer;

let pool = DescriptorPool::decode(include_bytes!("file_descriptor_set.bin").as_ref()).unwrap();
let message_descriptor = pool.get_message_by_name("package.MyMessage").unwrap();

let json = r#"{ "foo": 150 }"#;
let mut deserializer = Deserializer::from_str(json);
let dynamic_message = DynamicMessage::deserialize(message_descriptor, &mut deserializer).unwrap();

assert_eq!(dynamic_message.get_field_by_name("foo").unwrap().as_ref(), &Value::I32(150));

Example - implementing ReflectMessage

The ReflectMessage trait provides a .descriptor() method to get type information for a message. It is implemented for DynamicMessage and the well-known-types provided by prost-types.

When the derive feature is enabled, it can be derived for Message implementations. The derive macro takes the following parameters:

Name Value
descriptor_pool An expression that resolves to a DescriptorPool containing the message type. The descriptor should be cached to avoid re-building it. Either this or file_descriptor_pool_bytes must be set
file_descriptor_pool_bytes An expression that resolves to an implementation of Buf containing an encoded file descriptor set. This will be automatically added to the global descriptor pool the first time ReflectMessage::descriptor() is called.
message_name The full name of the message, used to look it up within DescriptorPool.
use prost::Message;
use prost_reflect::{DescriptorPool, ReflectMessage};
use once_cell::sync::Lazy;

static DESCRIPTOR_POOL: Lazy<DescriptorPool>
    = Lazy::new(|| DescriptorPool::decode(include_bytes!("file_descriptor_set.bin").as_ref()).unwrap());

#[derive(Message, ReflectMessage)]
#[prost_reflect(descriptor_pool = "DESCRIPTOR_POOL", message_name = "package.MyMessage")]
pub struct MyMessage {}

let message = MyMessage {};
assert_eq!(message.descriptor().full_name(), "package.MyMessage");

If you are using prost-build, the prost-reflect-build crate provides helpers to generate ReflectMessage implementations:

    .compile_protos(&["src/package.proto"], &["src"])

Minimum Supported Rust Version

Rust 1.64 or higher.

The minimum supported Rust version may be changed in the future, but it will be done with a minor version bump.


Licensed under either of

at your option.


Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.


~248K SLoC