bufbuild

hyperpb-go: Parse Dynamic Protobuf Messages Faster in Go

Buf’s hyperpb-go is a Go library for fast, read-only parsing of dynamic Protobuf messages, built on an UPB-inspired table-driven parser. It targets reflection-based workloads and claims substantial speedups over dynamicpb and generated Go code.

QuietGoApache-2.0GolangLibraryPerformance
Stars
689
Forks
17
Stars, last 30 days
+1
Last commit
4 months ago
Contributors
10

Our take

Quietno commits in the last 90 days and no release in a year

Health score

24/100

How it is scored
Activity
19
Community
36
Issues
21
Pull requests
20

+1 stars in the last 30 days

hyperpb-go is a specialized performance option for read-only dynamic Protobuf workloads, but its experimental API and quiet recent development call for careful evaluation before adoption.

Good fit if

  • Your Go service handles runtime-loaded Protobuf schemas and needs reflection-based parsing.
  • You can use amd64 or arm64, and can keep messages read-only.
  • You can benchmark it against your workload and accept an Apache-2.0 dependency.

Look elsewhere if

  • Your application needs to mutate parsed messages or needs support for other architectures.
  • You require recent releases or active issue and pull-request handling: there have been no commits in the last 90 days, no release in over a year, and no issues or PRs were closed or merged in that period.
  • You need a project with broadly distributed maintenance; most of the code comes from one person.
All health signals
Last commit2026-07-28 (4 months ago)
Commits, last 90 days0
Releases, last 12 months0 (latest v0.1.3, 2025-09-24)
Contributors10 (top contributor: 82% of commits)
Issues closed, last 90 days0
Pull requests merged, last 90 days0
Project age16 months

Checked on 2026-11-17 with the GitHub API.

Project history

Daily GitHub snapshots since Oct 7, 2026. History covers stars and forks; health signals are not tracked historically.

Selected snapshot

Stars

689

Forks

17

Change since Nov 18, 2026: 0 stars·0 forks

Overview

Buf’s hyperpb-go provides hyperpb, a Go library for parsing dynamic Protobuf messages. It uses an optimized virtual machine for a table-driven parsing approach pioneered by UPB, aiming to make reflection-based, read-only workloads faster than Go’s canonical dynamicpb library.

It is intended for services that work with runtime-loaded schemas or otherwise need generic message handling. Messages can be parsed and read through the Protobuf reflection API, but cannot be mutated after parsing. The library supports 64-bit x86 and ARM targets, known in Go as amd64 and arm64.

Key Features

  • Compiles message parsers at runtime from descriptors or descriptor sets, so schemas can be loaded dynamically.
  • Works with standard Protobuf APIs such as proto.Unmarshal and protojson.Marshal.
  • Supports reading populated fields through reflection, including iteration with Range.
  • Offers compile-time and unmarshal options, including extension resolution and decode-miss limits.
  • Provides reusable Shared state for managing message memory across parses.
  • Supports profile-guided optimization using recorded message workloads.
  • Implements Protobuf language constructs, while leaving parsed messages read-only.

Use Cases

  • A schema-registry-backed service that receives message types at runtime and needs to parse or inspect their payloads.
  • A generic transcoding service that converts dynamic Protobuf messages to JSON without generating Go types for every schema.
  • A read-only validation pipeline that applies reflection-based validation to parsed messages.
  • A high-throughput service parsing deeply nested messages, where profiling real traffic could help tune parser behavior.

What you need

Detected in the repository

  • Go 1.25.0 or newer (from go.mod)
  • Automated checks on GitHub Actions

License in plain words

Apache-2.0permissive

  • Commercial use: yes
  • Modify and redistribute: yes
  • You must keep: the license, the NOTICE file and a note of your changes
  • Share your changes: no
  • Includes an explicit patent grant from the contributors:

A summary, not legal advice: the LICENSE file is what applies.

Getting Started

Install the Go module:

go get buf.build/go/hyperpb

Compile a message type, create a message, and parse with proto.Unmarshal. See the README for descriptor-based setup, memory reuse, and profiling examples.

Considerations

The project describes itself as experimental, and its API may change substantially before v1. Parsed messages are not mutable, and the library is limited to 64-bit x86 and ARM; other architectures are unsupported. The repository has been quiet recently, has had no release in over a year, and its contributions are concentrated in one person. It requires Go 1.25.0. The Apache-2.0 license is permissive, but teams should still account for its terms when distributing the library.

Found this useful?

Share it with someone who would like hyperpb-go.