explaingit

tokio-rs/prost

4,690RustAudience · developerComplexity · 3/5Setup · moderate

TLDR

Prost is a Rust library that generates native Rust structs and enums from Protocol Buffer schema files, so you can efficiently serialize and deserialize structured data in Rust programs.

Mindmap

mindmap
  root((repo))
    What it does
      Generate Rust types
      Encode to bytes
      Decode from bytes
    Schema to code
      Proto file input
      prost-build crate
      Build script integration
    Type mappings
      String to String
      Repeated to Vec
      Optional to Option
    Design choices
      No runtime reflection
      Plain Rust structs
      Derive macros only
Click or tap to explore — scroll the page freely

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

Things people build with this

USE CASE 1

Define a .proto schema for a gRPC service and use prost-build to auto-generate the Rust message types in your build script.

USE CASE 2

Serialize and deserialize structured data between Rust microservices using the compact protobuf binary encoding.

USE CASE 3

Integrate protobuf message types into a Tokio-based async Rust project without a separate runtime reflection library.

USE CASE 4

Replace manual struct definitions for network protocol messages with auto-generated, type-safe Rust code from .proto files.

Tech stack

Rust

Getting it running

Difficulty · moderate Time to first run · 30min

Requires adding prost-build as a build dependency and writing a build.rs script.proto file compilation happens automatically at build time.

License terms are not specified in the repository documentation.

In plain English

Prost is a Rust library that implements Protocol Buffers, a format for efficiently encoding structured data so it can be sent between programs or stored compactly. Protocol Buffers, often called protobuf, were originally developed at Google and are widely used in networked systems and APIs where performance and compact encoding matter. You define your data structures in a special schema file with a .proto extension, and a code generator reads that file and produces ready-to-use code in your chosen programming language. Prost handles the Rust side of that process. You write your schema files, and prost generates plain Rust structs and enums that match your definitions. The generated types are ordinary Rust code, using standard Rust features like derive macros rather than introducing a separate class hierarchy or requiring a runtime library to introspect your types. The README notes that prost does not support runtime reflection, which is a deliberate tradeoff in favor of keeping generated code simple and lightweight. The companion crate prost-build integrates the code generation step into Rust's build system, so the .proto files are compiled automatically when you build your project. The README walks through how different protobuf field types map to Rust types (for example, a protobuf string becomes a Rust String, a repeated field becomes a Vec, and an optional message field becomes an Option), and how protobuf packages map to Rust modules. The project lives under the tokio-rs organization on GitHub, which is the team behind the Tokio asynchronous runtime for Rust. Prost is described as passively maintained, meaning it accepts contributions and fixes bugs but is not under active feature development. It supports Rust version 1.82 and above, following the same minimum version policy as the Tokio project.

Copy-paste prompts

Prompt 1
I have a .proto file defining a User message with fields for id, name, and email. Show me how to set up prost-build in my Rust build.rs to generate the Rust types.
Prompt 2
Write a Rust example that serializes a prost-generated struct to bytes and deserializes it back, using the encode and decode methods.
Prompt 3
My protobuf message has a oneof field. Explain how prost represents this in Rust and show me how to match on the variants.
Prompt 4
Set up a minimal Rust project with prost that can read a binary protobuf file from disk and print the decoded fields.
Prompt 5
How do I handle proto3 optional fields in prost? Show me the difference between a required string field and an optional message field in the generated Rust types.
Open on GitHub → Explain another repo

← tokio-rs on gitmyhub — every repo by this author, as a profile.

Verify against the repo before relying on details.