repository·main·Indexed 13 days ago
https://github.com/protocolbuffers/protobufGoogle's language-neutral, platform-neutral, extensible mechanism for serializing structured data. It allows developers to define data structures in .proto files and generate code for various programming languages to handle serialization and deserialization.
The upb Lua bindings are bare-bones bindings for Lua provided via the upb (micro-protobuf) library.
Warning: These bindings are intended primarily for experimentation and testing. They are incomplete, not intended for production applications, and are not a complete or supported protobuf library. The project does not claim them to be fully functional.
upb (μpb) is a small, fast C implementation of Protocol Buffers. It is designed to be an order of magnitude smaller in code size than the C++ implementation while maintaining comparable speed.
oneofs, maps, unknown fields, extensions, etc.protoc.The utf8_range library implements high-performance UTF-8 string validation using SIMD instructions. It provides several implementations optimized for different architectures and methods:
These leverage a range-based algorithm to validate 16 bytes at once using SIMD.
range-neon.c: NEON version (for armv8a)range-sse.c: SSE4 version (for x86)range-avx2.c: AVX2 version (for x86)range2-neon.c / range2-sse.c: Optimized versions that process two blocks in a single iteration.lemire-sse.c), AVX2 (lemire-avx2.c), and NEON (lemire-neon.c).naive.c).lookup.c).The Protocol Buffers ecosystem includes various specialized tools for different tasks:
pbjson) for Protobuf $\leftrightarrow$ JSON serialization.protoc-gen-fieldmask: Generates static type fieldmask paths.Proto Boiler: Generates boilerplate code from .proto files using templates.grpc-federation: Generates a gRPC server by writing custom options in Protobuf.google.protobuf.text_format module provides utilities for parsing and printing Protocol Buffer messages in a human-readable text format. This is useful for debugging, configuration files, or logging, as it allows you to represent structured protobuf data as plain text and vice versa.The files in this directory are historical design documents describing the implementation plans for Protobuf Editions. They are provided for historical context and may be outdated.
For the most up-to-date, authoritative information on how to use and implement Protobuf Editions, refer to the official Protobuf Editions Overview.
The Protobuf project supports multiple C++ build systems to ensure compatibility across different development environments. While the project primarily uses Bazel as its primary build system for the C++ runtime and the Protobuf compiler, it also provides support for CMake.
Although Bazel and CMake have different semantics and structures, they both rely on the same underlying list of files required to build the runtime and the compiler. This design allows Protobuf to maintain a single source of truth for build definitions while catering to the diverse ecosystem of C++ build tools.
upb is a high-performance, small-footprint protobuf kernel written in C. It is designed as a low-level kernel intended to be wrapped by other language runtimes (e.g., Go, Python, Ruby) rather than being used directly by application developers.
Key Characteristics:
The hpb generator is used to create code for the hpb API, which is an experimental C++ implementation of Protocol Buffers.
Note: This is an experimental implementation. For production use or standard requirements, you should use the standard C++ implementation instead.
Protobuf Editions aims to introduce new semantics while ensuring mechanical, incremental upgradability. To avoid the fragmentation seen between proto2 and proto3, the tooling is designed to automate major migration steps.
Key tools include:
protoc mode that cleans up .proto files by minimizing explicit feature declarations without changing semantics (e.g., moving features from individual fields to a parent message if they are identical).protoc mode that migrates proto2 or proto3 files into a specific edition.These tools are intended to be bundled with protoc and operate by producing or applying a ProtoChangeSpec.
Features evolve through a structured lifecycle to allow for safe, incremental migrations:
2025) that introduces a feature with a default value that matches existing behavior (a no-op migration)..proto files to prepare for future changes.2027) changes the default value of that feature. Files that were already explicitly setting the new value experience no change; files relying on the old default must be updated.The repeated_field_encoding feature controls how repeated fields are encoded. It defaults to PACKED (matching proto3 behavior).
Values:
PACKED: Matches proto3 default.EXPANDED: Corresponds to proto2 default.Note: All packed and unpacked field options from legacy syntax should be replaced with this feature during migration.
// Example: Converting proto2 default (expanded) to edition zero
edition = "2023";
features.repeated_field_encoding = EXPANDED;
message Foo {
repeated int32 bar = 1;
repeated int32 baz = 2 [features.repeated_field_encoding = PACKED];
}