# gRPC Go Tooling and Generators

> Search results for `gRPC tooling and code generation for Go` on awesome-repositories.com. 91 total matches; showing the first 50.

Explore on the web: https://awesome-repositories.com/q/grpc-tooling-and-code-generation-for-go

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [this search on awesome-repositories.com](https://awesome-repositories.com/q/grpc-tooling-and-code-generation-for-go).**

## Results

- [grpc/grpc](https://awesome-repositories.com/repository/grpc-grpc.md) (44,891 ⭐) — gRPC is a language-agnostic remote procedure call framework designed for high-performance communication between distributed services. It utilizes a structured interface definition language to generate consistent client stubs and server skeletons, enabling applications to invoke methods on remote servers as if they were local objects. By leveraging the HTTP/2 transport layer, the framework supports efficient binary serialization and multiplexed data exchange across diverse programming environments.

The framework distinguishes itself through its support for flexible communication patterns, incl
- [grpc/grpc-rust](https://awesome-repositories.com/repository/grpc-grpc-rust.md) (12,338 ⭐) — grpc-rust is a native gRPC framework for Rust designed for building high-performance remote procedure call clients and servers. It provides an asynchronous communication stack and a protocol buffers implementation for encoding, decoding, and generating type-safe code from service definitions.

The project enables the implementation of unary and bi-directional data streaming over the HTTP/2 protocol. It includes specialized support for gRPC-Web integration, allowing browser-based clients to communicate with services through protocol translation.

The infrastructure covers a broad range of distr
- [grpc/grpc-go](https://awesome-repositories.com/repository/grpc-grpc-go.md) (22,962 ⭐) — grpc-go is a Go language implementation of the gRPC framework, providing a remote procedure call library for high-performance service communication. It uses the HTTP/2 protocol to execute functions on remote servers as if they were local methods and utilizes protobuf service bindings to generate type-safe client and server code.

The project features a bidirectional streaming transport that supports asynchronous, full-duplex message streams between clients and servers. This networking layer allows for various communication patterns, including client-to-server and server-to-client streaming, to
- [grpc-ecosystem/go-grpc-middleware](https://awesome-repositories.com/repository/grpc-ecosystem-go-grpc-middleware.md) (6,749 ⭐) — go-grpc-middleware is a gRPC middleware framework for Go designed to handle cross-cutting concerns, reliability, and observability. It provides a collection of interceptors that can be used to modify inbound and outbound calls to enforce system-wide policies.

The framework distinguishes itself through specialized toolkits for service reliability, including automatic retry logic for failed client calls and panic recovery mechanisms that translate runtime crashes into standard error responses. It also features an observability suite for collecting performance metrics and recording request activ
- [grpc-ecosystem/grpc-gateway](https://awesome-repositories.com/repository/grpc-ecosystem-grpc-gateway.md) (19,930 ⭐) — This project is a REST-to-gRPC API gateway and JSON reverse proxy that translates RESTful HTTP requests into gRPC service calls. It functions as a protocol buffer proxy generator, providing the tools necessary to bridge JSON-based HTTP traffic with backend gRPC servers.

The system distinguishes itself by automating the creation of reverse-proxy servers and stubs through protobuf-driven code generation. It also includes a dedicated OpenAPI specification generator that produces OpenAPI v2 and v3 documents from gRPC service definitions and annotations.

The project covers a broad range of integr
- [usebruno/bruno](https://awesome-repositories.com/repository/usebruno-bruno.md) (44,931 ⭐) — Bruno is a local-first API client designed for building, testing, and managing network requests across a wide range of protocols. By storing all collections and configurations as plain-text files directly on the local filesystem, it enables native version control and offline access, ensuring that project data remains under user control without requiring cloud synchronization.

The platform distinguishes itself through a declarative approach to API management, utilizing a domain-specific language to define request parameters and metadata. This architecture supports a robust testing environment
- [grpc/grpc-web](https://awesome-repositories.com/repository/grpc-grpc-web.md) (9,229 ⭐) — gRPC-Web is a JavaScript client library that enables browser applications to call gRPC services through an HTTP proxy, using Protocol Buffers for serialization. It provides a browser-based gRPC client that supports unary, server-streaming, and bidirectional streaming RPCs, along with a code generator that produces JavaScript and TypeScript client stubs from .proto service definitions.

The library includes an interceptor framework for attaching cross-cutting logic like authentication and retries to client calls, and supports setting Unix timestamp deadlines on RPCs for server-side timeout enfo
- [gofr-dev/gofr](https://awesome-repositories.com/repository/gofr-dev-gofr.md) (21,321 ⭐) — Gofr is a comprehensive framework for building production-ready microservices in Go. It provides a unified toolkit for developing RESTful APIs and gRPC services, offering built-in support for observability, database management, and distributed system communication.

The framework distinguishes itself through its focus on developer productivity and system resilience. It automates common backend tasks such as CRUD handler generation, schema-driven code creation, and database migration orchestration, while preventing race conditions in clustered environments. To maintain stability, it includes in
- [openapitools/openapi-generator](https://awesome-repositories.com/repository/openapitools-openapi-generator.md) (26,412 ⭐) — This project is a command-line tool and template-based scaffolding engine that transforms API interface specifications into functional client libraries and server stubs. By automating the creation of type-safe SDKs and boilerplate code, it bridges the gap between service definitions and implementation, allowing developers to maintain synchronized codebases across many programming languages.

The tool distinguishes itself through a portable execution model that utilizes containerized build isolation to ensure identical output regardless of the host environment. It features a modular, plugin-bas
- [go-swagger/go-swagger](https://awesome-repositories.com/repository/go-swagger-go-swagger.md) (9,989 ⭐) — go-swagger is a toolkit for working with Swagger/OpenAPI 2.0 specifications in Go. It generates server, client, and CLI code from a specification document, and can also produce a specification by scanning annotated Go source code. The project includes a static validation engine that checks documents against the schema and project-specific rules, and a specification transformation pipeline that resolves, flattens, and merges documents.

The toolkit generates both client and server code from the same specification, ensuring consistency in request and response handling. It also produces a command
- [inspektor-gadget/inspektor-gadget](https://awesome-repositories.com/repository/inspektor-gadget-inspektor-gadget.md) (2,720 ⭐) — Inspektor Gadget is an eBPF observability toolset and program framework designed for tracing Linux systems and debugging Kubernetes nodes. It provides a suite of tools to collect kernel-level telemetry and export system metrics via the OpenTelemetry standard.

The project distinguishes itself by packaging inspection tools as OCI-compliant container images, allowing for standardized distribution and deployment across clusters and hosts. It employs a modular data processing pipeline that utilizes WebAssembly modules to transform and filter telemetry, and leverages Compile Once Run Everywhere for
- [grpc/grpc-dotnet](https://awesome-repositories.com/repository/grpc-grpc-dotnet.md) (4,469 ⭐) — gRPC for .NET
- [avelino/awesome-go](https://awesome-repositories.com/repository/avelino-awesome-go.md) (175,576 ⭐) — This project serves as a comprehensive language ecosystem index, functioning as a centralized, community-curated directory for the Go programming language. It organizes a vast landscape of software components, libraries, and development tools into a structured, navigable hierarchy, enabling developers to efficiently discover resources tailored to specific functional domains.

The repository distinguishes itself through a decentralized contribution model, where community-driven updates ensure the index remains current with the rapidly evolving software landscape. Beyond simple resource listing,
- [hyperf/hyperf](https://awesome-repositories.com/repository/hyperf-hyperf.md) (6,855 ⭐) — Hyperf is a high-performance PHP coroutine framework designed for building microservices and middleware. It utilizes non-blocking coroutines to handle high concurrency and low-latency request processing, providing a foundation for scalable distributed systems.

The framework is distinguished by an aspect-oriented programming based dependency injector that enables pluggable components and meta-programming. It includes a coroutine-optimized object-relational mapper with integrated model caching and an orchestration toolkit for microservice governance, featuring service discovery, circuit breaker
- [quarkusio/quarkus](https://awesome-repositories.com/repository/quarkusio-quarkus.md) (15,479 ⭐) — Quarkus is a Kubernetes-native Java framework designed for building high-performance, memory-efficient applications. It utilizes ahead-of-time native compilation to transform Java code into standalone, optimized binaries that eliminate the need for a virtual machine, enabling rapid startup and reduced memory consumption. By performing code augmentation during the build phase, it shifts heavy processing tasks away from runtime, ensuring that applications are optimized for cloud-native environments.

The framework distinguishes itself through a unified approach to reactive and imperative program
- [jaegertracing/jaeger](https://awesome-repositories.com/repository/jaegertracing-jaeger.md) (22,890 ⭐) — Jaeger is a distributed tracing platform used for collecting, storing, and visualizing request flows across microservices. It identifies performance bottlenecks and errors by tracking requests as they move through multiple service boundaries. The system includes telemetry collectors, a multi-tenant backend, and a trace visualizer.

The platform provides a multi-tenant tracing infrastructure that isolates data and queries by tenant to support shared environments. It supports standardized telemetry ingestion via the OpenTelemetry Protocol over gRPC and HTTP. To manage storage costs and overhead,
- [appleboy/gorush](https://awesome-repositories.com/repository/appleboy-gorush.md) (8,738 ⭐) — Gorush is a dedicated notification dispatch server used to send real-time alerts to iOS and Android mobile devices. It functions as a centralized infrastructure for hosting a notification API and managing the delivery of push messages through high-throughput queuing.

The system supports both gRPC streams and HTTP endpoints to receive notification triggers and includes a command-line interface for triggering alerts without a running server process. It manages network traffic through proxy routing via HTTP or SOCKS5 and secures server communication using automated TLS certificate management.

O
- [arize-ai/phoenix](https://awesome-repositories.com/repository/arize-ai-phoenix.md) (8,605 ⭐) — Arize Phoenix is an LLM observability platform and evaluation framework designed to capture execution traces and monitor large language model applications. It serves as a prompt management system for versioning and testing templates, and as a self-hosted AI operations infrastructure for managing telemetry and experiments.

The platform differentiates itself through a specialized embedding visualization tool used to detect data drift and optimize vector search. It provides a comprehensive evaluation suite that utilizes judge-based evaluators and ground-truth datasets to score model outputs, and
- [protocolbuffers/protobuf](https://awesome-repositories.com/repository/protocolbuffers-protobuf.md) (71,359 ⭐) — Protocol Buffers is a language-neutral, platform-agnostic mechanism for serializing structured data. It provides a schema-driven toolchain that compiles declarative data definitions into type-safe source code, enabling consistent communication and strongly typed API contracts across services written in different programming languages.

The project distinguishes itself through a highly efficient binary wire format that utilizes tag-based encoding and variable-width integer compression to minimize payload size and processing overhead. It supports robust evolutionary schema management, allowing d
- [drizzle-team/drizzle-orm](https://awesome-repositories.com/repository/drizzle-team-drizzle-orm.md) (34,835 ⭐) — Drizzle ORM is a TypeScript-native database toolkit providing type-safe SQL query building, schema management, and automated migrations across PostgreSQL, MySQL, SQLite, and SingleStore.
- [roadrunner-server/roadrunner](https://awesome-repositories.com/repository/roadrunner-server-roadrunner.md) (8,473 ⭐) — RoadRunner is a high-performance application server and process manager designed to serve PHP applications using a persistent worker model. It eliminates bootload overhead and initialization time by keeping application processes alive between requests, acting as a protocol-agnostic proxy that routes traffic to a pool of supervised workers.

The server is built with a plugin-based modular architecture, allowing it to be extended with custom Go plugins and compiled into tailored binaries. It distinguishes itself by providing a unified execution model for a wide array of communication protocols,
- [grpc/grpc-node](https://awesome-repositories.com/repository/grpc-grpc-node.md) (4,833 ⭐) — Directory: packages/grpc-native-core (see here for installation information)
- [youtube/vitess](https://awesome-repositories.com/repository/youtube-vitess.md) (21,032 ⭐) — Vitess is a distributed MySQL orchestrator and clustering system designed for horizontal database scaling. It functions as sharding middleware that distributes data and load across multiple MySQL instances to handle growth beyond the capacity of a single machine.

The system provides a proxy layer that abstracts data distribution, allowing applications to query a cluster as a single logical database without knowing the physical location of the data. This is achieved through a routing mechanism that intercepts queries and directs them to the appropriate shards based on keyspace mappings.

The p
- [qdrant/qdrant](https://awesome-repositories.com/repository/qdrant-qdrant.md) (32,372 ⭐) — Qdrant is a high-performance vector similarity database designed to store, index, and search high-dimensional vectors alongside structured metadata. It functions as a distributed search engine that manages large-scale data clusters, providing low-latency retrieval and complex filtering capabilities. The system is built to serve as a specialized middleware layer, connecting machine learning pipelines and AI agents to persistent storage for intelligent information retrieval and recommendation tasks.

The platform distinguishes itself through advanced retrieval techniques, including support for h
- [dominikh/go-tools](https://awesome-repositories.com/repository/dominikh-go-tools.md) (6,818 ⭐) — go-tools is a collection of utilities for Go static analysis and memory layout optimization. It provides a toolset designed to analyze source code to detect bugs and dead code, alongside specialized tools for optimizing how structs are arranged in memory.

The project includes a memory alignment visualizer to display physical memory layouts and padding, as well as a struct layout optimizer that reorders fields to minimize memory padding. Additionally, it provides a boilerplate generator to automate the creation of registration and test files required for developing custom Go analyzers.

The to
- [anthropics/claude-code](https://awesome-repositories.com/repository/anthropics-claude-code.md) (132,728 ⭐) — Anthropic's terminal-native AI coding agent.
- [apache/brpc](https://awesome-repositories.com/repository/apache-brpc.md) (17,545 ⭐) — brpc is a high-performance C++ RPC framework and network programming library designed for building distributed systems. It functions as a multi-protocol RPC server capable of hosting and detecting multiple communication protocols, including gRPC, Thrift, HTTP, Redis, and Memcached, on a single TCP port.

The project distinguishes itself through high-throughput data transport and memory efficiency, utilizing RDMA-based transport to bypass the kernel TCP stack and zero-copy memory management to eliminate data duplication. It also implements the Raft algorithm for consensus-based state replicatio
- [grpc-ecosystem/grpc-spring](https://awesome-repositories.com/repository/grpc-ecosystem-grpc-spring.md) (3,706 ⭐) — grpc-spring is a framework for integrating gRPC servers and clients into Spring applications. It provides a suite of tools for managing the lifecycle of remote procedure call servers, automating client stub injection, and implementing request interception within a Java environment.

The project enables high-performance remote procedure call communication through annotation-driven service registration and automatic configuration of client stubs. It includes a specialized interceptor library for modifying requests and responses, as well as a telemetry tool for exporting performance metrics and d
- [moby/buildkit](https://awesome-repositories.com/repository/moby-buildkit.md) (10,061 ⭐) — Buildkit is a programmable container build toolkit and OCI container image builder that converts build definitions into concurrent dependency graphs for image construction. It functions as an OCI image distribution engine, capable of generating container images and exporting artifacts to local storage or remote registries.

The project is distinguished by its use of a low-level binary intermediate representation to decouple high-level build languages from the execution engine. It supports multi-platform image builds through user-mode architecture emulation and provides a distributed build cach
- [otwieracz/clj-grpc](https://awesome-repositories.com/repository/otwieracz-clj-grpc.md) (17 ⭐) — A Clojure library designed to provide hassle-free, ready to go gRPC experience without ton of preparations and Java code.
- [analysis-tools-dev/static-analysis](https://awesome-repositories.com/repository/analysis-tools-dev-static-analysis.md) (14,389 ⭐) — This project is a comprehensive, curated directory of static analysis, linting, and security scanning utilities. It serves as a central resource for developers to discover, compare, and select tools based on specific programming languages, licensing models, and integration requirements.

The directory distinguishes itself by providing deep metadata for each listed utility, including community-driven popularity rankings, maintenance status, and deployment methods. By aggregating these tools into a single searchable index, it enables teams to identify solutions for enforcing coding standards, ma
- [cloudwego/kitex](https://awesome-repositories.com/repository/cloudwego-kitex.md) (7,973 ⭐) — Kitex is a high-performance remote procedure call framework for building distributed microservices in Go. It provides a communication system compatible with gRPC and Protobuf standards and includes a suite of tools for microservices governance.

The framework features proxyless service mesh integration, which allows it to manage network traffic and governance directly without adding sidecar proxy latency. It optimizes data throughput through a high-performance communication library that minimizes memory copies.

The system covers a broad surface of distributed capabilities, including service d
- [likec4/likec4](https://awesome-repositories.com/repository/likec4-likec4.md) (2,723 ⭐) — likec4 is an architecture-as-code framework that transforms text-based architecture definitions into interactive diagrams, static websites, and image files. It serves as a system architecture visualizer and C4 model diagram generator, allowing users to define software components, boundaries, and deployment infrastructure using a domain-specific language.

The tool distinguishes itself by providing a modeling environment with Language Server Protocol integration for real-time validation and autocomplete. It enables interactive architecture documentation where users can navigate through hierarch
- [teleporthq/teleport-code-generators](https://awesome-repositories.com/repository/teleporthq-teleport-code-generators.md) (1,113 ⭐) — A collection of code generators for modern JavaScript applications
- [salesforce/reactive-grpc](https://awesome-repositories.com/repository/salesforce-reactive-grpc.md) (841 ⭐) — Reactive gRPC is a suite of libraries for using gRPC with Reactive Streams programming libraries. Using a protocol buffers compiler plugin, Reactive gRPC generates alternative gRPC bindings for each reactive technology. The reactive bindings support unary and streaming operations in both…
- [nrwl/nx](https://awesome-repositories.com/repository/nrwl-nx.md) (28,939 ⭐) — This project is a build orchestration engine and development toolkit designed for managing large-scale monorepos. It provides a unified workspace environment that maps project relationships and dependencies, enabling the system to perform intelligent impact analysis and execute only the tasks affected by specific code changes.

The system distinguishes itself through a persistent daemon that monitors file changes for near-instant feedback and a content-addressable caching mechanism that stores task outputs to prevent redundant computation across local and remote environments. It further suppor
- [coreos/etcd](https://awesome-repositories.com/repository/coreos-etcd.md) (51,846 ⭐) — etcd is a distributed key-value store and configuration store designed to maintain a consistent set of data across a cluster of nodes. It functions as a reliable registry for storing and synchronizing critical settings and metadata used by distributed applications.

The system implements the Raft consensus algorithm to ensure data consistency and leader election across servers. To protect data transfers and verify node identities, it utilizes a network security layer based on mutual TLS and client certificates.

Its capabilities cover distributed configuration management, cluster state synchro
- [vercel/turborepo](https://awesome-repositories.com/repository/vercel-turborepo.md) (30,552 ⭐) — Turborepo is a build orchestrator designed to manage task execution within monorepos. It functions as a task pipeline manager that models workspace relationships as a directed acyclic graph, allowing it to coordinate complex build sequences and dependency orders across multiple interconnected packages.

The system accelerates development cycles through incremental task execution, which identifies and skips redundant work by analyzing file contents and environment variables to generate unique task identifiers. It leverages content-addressable caching to store build outputs locally or remotely,
- [cosmos/cosmos-sdk](https://awesome-repositories.com/repository/cosmos-cosmos-sdk.md) (7,016 ⭐) — Cosmos SDK is a modular blockchain application framework and software development kit used to build sovereign layer-one networks. It provides a foundation for creating customizable blockchains featuring native interoperability, sovereign governance, and Byzantine Fault Tolerant consensus engines.

The framework is distinguished by its inter-blockchain communication protocol, which enables the transfer of byte-encoded data and digital assets between independent blockchain networks. It supports multiple consensus models, including Proof of Stake and Proof of Authority, and allows for the integra
- [grpc/grpc-java](https://awesome-repositories.com/repository/grpc-grpc-java.md) (12,032 ⭐) — gRPC Java is a library for building distributed systems that enables client and server applications to interact through remote procedure calls. It uses protocol buffers to define service interfaces and exchange structured data, providing a framework for connecting microservices across different environments.

The framework utilizes an asynchronous networking foundation to manage concurrent connections and relies on a multiplexed binary protocol to facilitate efficient data exchange. It supports pluggable transport interceptors, allowing for the injection of custom logic into the request-respon
- [crestapps/laravel-code-generator](https://awesome-repositories.com/repository/crestapps-laravel-code-generator.md) (761 ⭐) — An intelligent code generator for Laravel framework that will save you time! This awesome tool will help you generate resources like views, controllers, routes, migrations, languages and/or form-requests! It is extremely flexible and customizable to cover many on the use cases. It is shipped…
- [koxudaxi/fastapi-code-generator](https://awesome-repositories.com/repository/koxudaxi-fastapi-code-generator.md) (1,398 ⭐) — This code generator creates FastAPI app from an openapi file.
- [nasa/fprime](https://awesome-repositories.com/repository/nasa-fprime.md) (10,766 ⭐) — F Prime is a component-based framework designed for the development and deployment of embedded and spaceflight software. It provides a modular architecture that decouples software logic from communication interfaces, allowing developers to define system structures through a domain-specific modeling language. This model-based approach enables automated code generation, ensuring consistency across complex system topologies while maintaining strict interface contracts between software modules.

The framework distinguishes itself through its integrated build system and ground data operations suite
- [code-and-comment/code-and-comment](https://awesome-repositories.com/repository/code-and-comment-code-and-comment.md) (0 ⭐)
- [grpc-ecosystem/grpc-simon-says](https://awesome-repositories.com/repository/grpc-ecosystem-grpc-simon-says.md) (0 ⭐) — This is an example project using gRPC and Kubernetes to build a multiplayer version of the game "Simon Says".
- [googleapis/googleapis](https://awesome-repositories.com/repository/googleapis-googleapis.md) (8,439 ⭐) — This project is a centralized API specification registry and governance framework. It serves as a source of truth for structured API schemas, gRPC definitions, and data models used to maintain consistency across a large ecosystem of services.

The system functions as a multi-language client generator, transforming standardized interface definitions into executable source code and language-specific libraries. This process ensures that client libraries and technical documentation remain synchronized by deriving them directly from the original interface definitions.

The project also covers the m
- [cloudwego/hertz](https://awesome-repositories.com/repository/cloudwego-hertz.md) (7,279 ⭐) — Hertz is a high-performance Go HTTP framework designed for building scalable microservices, RESTful APIs, and AI applications. It functions as a high-performance web server and a communication framework for microservices, utilizing non-blocking I/O and zero-copy memory management to handle high-concurrency traffic.

The project distinguishes itself through a microservices communication toolkit that supports high-efficiency remote procedure calls via gRPC and Thrift protocols. It implements an asynchronous middleware engine based on an onion model, allowing for a pluggable request-response pipe
- [nikhilsaraf/go-tools](https://awesome-repositories.com/repository/nikhilsaraf-go-tools.md) (17 ⭐) — A collection of tools for Golang
- [swig/swig](https://awesome-repositories.com/repository/swig-swig.md) (6,294 ⭐) — SWIG is a tool that generates wrapper code to expose C and C++ libraries to a wide range of higher-level programming languages. It reads annotated C/C++ header files and produces language-specific bindings from a single interface definition, supporting languages such as Python, Java, Ruby, C#, Perl, and many others. The generated wrapper code is free from the project's GPL license, allowing users to distribute it under their own terms.

The tool handles modern C++ features including templates, namespaces, smart pointers, and constructs up to C++20 through specialized parsing and code generatio
- [pydantic/pydantic](https://awesome-repositories.com/repository/pydantic-pydantic.md) (26,932 ⭐) — Pydantic is a data validation and serialization library that enforces schema constraints and performs type conversion on complex data structures. It utilizes standard Python type annotations to define data models, allowing developers to establish structured schemas that automatically enforce business rules and constraints without the need for custom domain-specific languages.

The library distinguishes itself by transforming high-level model definitions into optimized code during initialization to minimize runtime overhead. It supports recursive validation for nested data structures and employ