grpc/grpc-swift

This system is the gRPC Swift 1.x maintenance library, providing the core client and server implementations for high-performance, asynchronous remote procedure calls in Swift. It supports all standard gRPC communication patterns, including unary, streaming, and bidirectional calls, with native async/await concurrency and configurable TLS backends. The project also includes tooling for code generation from Protocol Buffers, runtime service reflection, and comprehensive interoperability and performance testing suites.

26 changes.

The project transitioned to a maintenance branch for gRPC Swift 1, restructuring the repository and relicensing it to Apache 2.0 while removing legacy build systems, examples, and outdated documentation. Significant work focused on modernizing the core API with new client connection management, refined call abstractions, and enhanced server contexts, alongside comprehensive updates to interoperability and performance testing suites.

15 changes.

This period focused on integrating Swift's structured concurrency by introducing comprehensive async/await APIs for both gRPC clients and servers, supported by new call handlers and TLS backend options. It also established a flexible interceptor pipeline for cross-cutting concerns and enhanced connection management with a redesigned connection pool. The work was underpinned by extensive testing, including code generation validation, allocation monitoring, and fuzzing for edge cases.

13 changes.

The project refactored the async server handler to use explicit state machines for stricter protocol validation and migrated v1 examples to modern Swift concurrency APIs. It also introduced a SwiftPM build plugin for code generation and implemented the gRPC Reflection Service with comprehensive test coverage for both v1 and v1alpha protocols.

The QPSBenchmark tool now includes a new asynchronous runtime for both client and server sides, allowing users to run performance benchmarks using Swift's async/await APIs. This change introduces new service providers and client implementations that leverage the async GRPC APIs, supporting unary and streaming ping-pong scenarios. The benchmark worker can now be configured to use async threads, providing an alternative to the existing synchronous implementation for measuring performance characteristics under async execution models.

Performance/QPSBenchmark · high confidence

This change introduces generated Swift code for the gRPC Server Reflection service, enabling clients to inspect service definitions at runtime. It adds support for both the stable v1 API (under \Sources/GRPCReflectionService/v1\) and the deprecated v1alpha API (under \Sources/GRPCReflectionService/v1Alpha\). The included files define the necessary protobuf message types (such as \ServerReflectionRequest\ and \ServerReflectionResponse\) and the server-side handler protocols (\ServerReflectionProvider\ and \ServerReflectionAsyncProvider\) required to implement the \ServerReflectionInfo\ bidirectional streaming method for each version.

Sources/GRPCReflectionService/v1, Sources/GRPCReflectionService/v1Alpha · high confidence

A new command-line tool, ConnectionBackoffInteropTestRunner, has been added to verify that the gRPC client implementation correctly handles connection backoff and retry logic. The tool connects to a C++ interoperability test server, initiates a long-running RPC on a retry port to trigger reconnection attempts, and validates that the server reports the backoff behavior as passed. Users can run this test by providing control and retry ports, with the process taking approximately 10 minutes to complete.

Sources/GRPCConnectionBackoffInteropTest · high confidence

This change introduces the CGRPCZlib module, which provides a thin C wrapper around the zlib library to support compression on the gRPC client. The module includes a header file with inline functions for standard zlib operations (deflate, inflate, and related utilities) and a minimal C source file to satisfy build toolchain requirements on macOS. This enables the client to compress outgoing data, improving network efficiency for large payloads.

Sources/CGRPCZlib · high confidence

The server now includes a new ReflectionService that allows clients to query service definitions, file descriptors, and extension numbers at runtime. This implementation supports both the standard v1 and the v1alpha reflection protocols, enabling tools to discover available gRPC services and inspect protobuf file descriptors without requiring external documentation.

Sources/GRPCReflectionService/Server · high confidence

Two new git commit templates have been added to the dev directory to guide contributors in writing structured commit messages. The standard template (git.commit.template) encourages a format including motivation, modifications, and result sections, while the version-bump template (version-bump.commit.template) provides a specific structure for release commits, ensuring the version number and user-agent string consistency are documented.

dev · high confidence

Added in-source fuzz testing capabilities for the server-side echo implementation. This includes a new C-based fuzzer entry point (ServerFuzzer) that interfaces with a Swift library (ServerFuzzerLib) to drive the echo services via an EmbeddedChannel. The setup uses symlinks to reference the existing EchoImplementation and EchoModel sources, allowing the fuzzer to exercise the server logic in-memory without requiring a live network connection.

FuzzTesting/Sources · high confidence

The \Sources/GRPCInteroperabilityTests\ target now includes a new \main.swift\ entry point that provides a command-line interface for managing and executing gRPC interoperability tests. Users can now start a test server with optional TLS support, run specific interoperability test cases against a remote host, or list available test names. This replaces previous ad-hoc execution methods with a structured CLI built on Swift Argument Parser, enabling easier integration into CI pipelines and local testing workflows.

Sources/GRPCInteroperabilityTests · high confidence

A new Swift Package Manager build plugin (Plugins/GRPCSwiftPlugin) is added, allowing users to generate gRPC Swift code directly from .proto files during the build process. The plugin reads a grpc-swift-config.json configuration file to determine settings such as import paths, protoc location, and invocation options including visibility (internal, public, package), server/client code generation, reflection data, and method casing preservation. It integrates with SPM's build system by creating build commands that invoke protoc and protoc-gen-grpc-swift, outputting generated files to the plugin's work directory.

Plugins/GRPCSwiftPlugin · high confidence

This change adds a new \AsyncAwaitSupport\ module providing Swift concurrency-native wrappers for gRPC calls. For clients, it introduces \GRPCAsyncUnaryCall\, \GRPCAsyncServerStreamingCall\, \GRPCAsyncClientStreamingCall\, and \GRPCAsyncBidirectionalStreamingCall\, which expose request streams and response sequences via Swift's \AsyncSequence\ protocol and support cancellation via \withTaskCancellationHandler\. For servers, it provides \GRPCAsyncServerHandler\ and \GRPCAsyncServerCallContext\, allowing service implementations to be written as \async\ functions that interact with \GRPCAsyncRequestStream\ and \GRPCAsyncResponseStreamWriter\. The implementation relies on \NIOAsyncWriter\ and \NIOAsyncSequenceProducer\ from SwiftNIO to manage backpressure and stream lifecycles, and requires Swift 5.6+ due to the use of structured concurrency features.

Sources/GRPC/AsyncAwaitSupport · high confidence

Adds a new interceptor framework for gRPC calls, allowing developers to observe, mutate, or drop request and response parts. This change introduces \ClientInterceptor\ and \ServerInterceptor\ base classes, along with their respective \Context\ and \Pipeline\ implementations (\ClientInterceptorContext\, \ClientInterceptorPipeline\, \ServerInterceptorContext\, \ServerInterceptorPipeline\). It also defines the message part types (\GRPCClientRequestPart\, \GRPCClientResponsePart\, \GRPCServerRequestPart\, \GRPCServerResponsePart\) and a \ClientTransport\ that bridges the interceptor pipeline with the underlying NIO channel, enabling cross-cutting concerns like logging, authentication, or metrics to be applied to RPCs.

Sources/GRPC/Interceptor · high confidence

The library now supports enabling and configuring message compression for both client and server communications. Users can define which compression algorithms (gzip, deflate, or identity) are used for outbound requests and accepted for inbound responses via new \ClientMessageEncoding\ and \ServerMessageEncoding\ configurations. Additionally, a new \DecompressionLimit\ mechanism allows users to protect against resource exhaustion by setting either an absolute size cap or a compression-ratio limit on decompressed payloads; RPCs exceeding these limits are now cancelled.

Sources/GRPC/Compression · high confidence

The gRPC client connection API now exposes explicit builders for two TLS backends: NIOSSL and Network.framework. Users can configure NIOSSL-specific options such as certificate chains, private keys, trust roots, certificate verification modes, and custom verification callbacks via the \usingTLSBackedByNIOSSL\ builder. For Apple platforms (macOS 10.14+, iOS 12+, tvOS 12+, watchOS 6+), a new \usingTLSBackedByNetworkFramework\ builder allows setting local identities and custom handshake verification callbacks. A convenience \usingPlatformAppropriateTLS\ method automatically selects the correct backend based on the provided EventLoopGroup. The \ClientConnection.Builder\ also supports configuring connection backoff parameters (initial/max time, jitter, multiplier, timeout, retry limits) and enables connecting via a pre-connected socket.

Sources/GRPC/GRPCChannel · high confidence

The server-side call handling logic has been replaced with new, dedicated handler classes for each RPC style: Unary, Server Streaming, Client Streaming, and Bidirectional Streaming. These new handlers in Sources/GRPC/CallHandlers implement the GRPCServerHandlerProtocol and integrate with the interceptor pipeline, providing the underlying infrastructure for the async-await server implementation. This change introduces the specific handler components that process requests and manage the lifecycle of server-side RPCs.

Sources/GRPC/CallHandlers · high confidence

The repository now includes a suite of new scripts to support development workflows and release processes. These include \format.sh\ for Swift code formatting and linting, \license-check.sh\ to verify copyright headers, and \check-generated-code.sh\ to ensure generated Swift files are up-to-date. A new \bundle-plugins-for-release.sh\ script automates the creation of release zips for the gRPC and Protobuf protoc plugins. Additionally, \makecert\ and \make-sample-certs.py\ provide tools for generating test certificates for mutual TLS scenarios, while \alloc-limits.sh\ and \cg\_diff.py\ assist in performance analysis by parsing allocation counts and cachegrind output. The \fix-project-settings.rb\ script automates Xcode project configuration, and \run-plugin-tests.sh\ facilitates integration testing of the SwiftPM plugin across different gRPC Swift versions.

scripts · high confidence

Added new benchmark suites to measure gRPC performance in controlled environments. The EmbeddedClientThroughput benchmark tests client-side throughput using an embedded channel, while EmbeddedServer supports unary, client-streaming, server-streaming, and bidirectional streaming modes via an embedded server. A new MinimalEchoProvider implementation provides a lightweight echo service for these tests. Additionally, a PercentEncoding benchmark measures status message marshalling performance, and the existing ServerProvidingBenchmark infrastructure is utilized by UnaryThroughput (including bidirectional streaming) to measure end-to-end server throughput.

Sources/GRPCPerformanceTests/Benchmarks · high confidence

A new module, Sources/GRPCInteroperabilityTestModels, has been added to house the generated Swift models and source protobufs for gRPC interoperability testing. This includes the standard test service definitions (such as unary, streaming, and duplex calls) and a dedicated script to regenerate the code. The module also incorporates a patch to remove the 'UnimplementedCall' method from the generated server-side interfaces, ensuring that test servers do not implement this method while allowing clients to verify behavior when calling unimplemented endpoints.

Sources/GRPCInteroperabilityTestModels · high confidence

The \GRPCInteroperabilityTestsImplementation\ target now provides a complete, self-contained implementation of the gRPC interoperability test suite. This includes a non-XCTest assertion framework for running tests in environments without XCTest, convenience methods for constructing test payloads and requests, and a full suite of client-side test cases (such as empty unary, large unary, compression, and streaming) that verify client behavior against a reference server. The implementation also includes a test server provider (both NIO callback-based and async) and credential management to facilitate end-to-end interoperability verification.

Sources/GRPCInteroperabilityTestsImplementation · high confidence

The Protos directory now includes a structured set of \.proto\ files and automation scripts to manage code generation. A new \fetch.sh\ script pulls upstream definitions from \grpc-proto\ and \googleapis\ into the \upstream/\ directory, covering services like Health, Reflection (v1 and v1alpha), Route Lookup Service, and core stats. Example definitions for Echo and RouteGuide are added under \examples/\, alongside test definitions for Control and normalization. A new \generate.sh\ script automates the generation of Swift and gRPC Swift code from these protos, targeting specific output paths for v1 examples, the GRPCReflectionService, and various test suites.

Protos · high confidence

The C bridge implementation files for the CgRPC package (including byte\_buffer, call, client, completion\_queue, handler, internal, metadata, mutex, observers, and server) have been deleted. This removes the low-level C functions and types that previously wrapped the gRPC library for Swift consumption.

Packages/CgRPC/Sources · high confidence

The legacy Swift gRPC command-line examples (Packages/Client and Packages/Server) have been removed. This includes the deletion of their respective Makefiles and main.swift source files, which previously demonstrated basic gRPC client-server communication, metadata handling, and request/response cycles using the older gRPC Swift API.

Packages/Client, Packages/Server · high confidence

The \gRPC.xcodeproj\ project file has been deleted, removing the manual Xcode build configuration that previously compiled Swift sources (such as \Client.swift\, \Call.swift\, and \Server.swift\) and C core files (like \client.c\ and \server.c\) into the \gRPC.framework\. This change indicates that the project has moved away from this specific manual build setup, likely replacing it with a generated project or a different build system, as suggested by the commit message noting it is replaced by \SwiftGRPC.xcodeproj\.

gRPC.xcodeproj · high confidence

The \Sessions.xcodeproj\ file, which defined the macOS 'Sessions' application built with Swift and gRPC, has been removed from the repository. This change eliminates the legacy example project that previously demonstrated session management using protocol buffers and the gRPC framework.

Examples/Sessions/Sessions.xcodeproj · high confidence

The legacy shell scripts (RUNME.sh, CLEANUP.sh) and the README.md file, which provided manual build and run instructions for Swift gRPC packages on Ubuntu 14.04, have been removed from the Packages directory. This cleanup eliminates outdated, unsupported build steps and documentation that relied on specific older toolchains and Docker configurations.

Packages · high confidence

The Sessions example application for macOS has been deleted. This removes the entire demo project, including the application entry point (AppDelegate), the main document interface (Document), the user interface layout files (MainMenu.xib, Document.xib), and the application configuration (Info.plist).

Examples/Sessions/Sessions · high confidence

The Swift implementation files for the gRPC package (including ByteBuffer, Call, Client, Server, Handler, and related components) have been deleted from the source tree.

Packages/gRPC/Sources · high confidence

The async server handler implementation has been restructured to use explicit state machines for managing the RPC lifecycle and interceptor pipeline. This change introduces dedicated state machines for the server handler (tracking Idle, Handling, Draining, and Finished states) and the interceptor pipeline (tracking Intercepting and Finished states), replacing the previous implicit control flow. For users, this ensures stricter validation of message ordering and state transitions, preventing protocol violations such as receiving metadata after the stream has ended or sending response headers after the RPC is finished, while maintaining the same public API behavior.

Sources/GRPC/AsyncAwaitSupport/AsyncServerHandler · high confidence

The v1 examples (Echo, HelloWorld, PacketCapture) have been updated to use the modern Swift gRPC async/await client and server APIs. Server implementations now conform to generated \*AsyncProvider protocols (e.g., EchoAsyncProvider, GreeterAsyncProvider) and client runtimes use generated \*AsyncClient types (e.g., Echo\_EchoAsyncClient, Helloworld\_GreeterAsyncClient). This shift replaces the previous NIO EventLoopFuture-based patterns with native Swift concurrency, simplifying the code and aligning the examples with current best practices for asynchronous gRPC calls.

Examples/v1 · high confidence

The connection pool logic in the gRPC client has been replaced with a new implementation. This new pool manages connections per event loop, tracks stream availability and utilization, supports configurable minimum connections and backoff strategies, and exposes public IDs for pools and sub-pools to aid in debugging and monitoring.

Sources/GRPC/ConnectionPool · high confidence

The GRPCPerformanceTests module has been restructured to provide a more flexible and comprehensive benchmarking framework. This change introduces a new \Benchmark\ protocol and utility functions in \Benchmark.swift\ and \BenchmarkUtils.swift\ to standardize how benchmarks are defined, set up, and measured. The \main.swift\ entry point now utilizes this new structure to run a wider variety of performance tests, including unary, bidirectional, and embedded server/client scenarios with configurable request sizes and batch counts. Additionally, the suite now supports a cachegrind mode for cache profiling and allows users to specify whether to use NIO Transport Services and TLS, providing more granular control over benchmark conditions.

Sources/GRPCPerformanceTests · high confidence

The client-side RPC implementation has been refactored to use a new \Call\ object that manages the RPC lifecycle, state, and interceptor pipeline, replacing the previous initialization-based request sending. New public call types—\UnaryCall\, \ServerStreamingCall\, \ClientStreamingCall\, and \BidirectionalStreamingCall\—now delegate to this core \Call\ implementation, providing a consistent API for sending messages, handling compression, and managing cancellation. The change also introduces \StreamingRequestClientCall\ and \UnaryResponseClientCall\ protocols to standardize request and response handling across different streaming modes, along with internal helpers like \LazyEventLoopPromise\ to optimize promise allocation.

Sources/GRPC/ClientCalls · high confidence

The library introduces a new \ClientConnection\ class and associated configuration structures (\CallOptions\, \ConnectionBackoff\, \ClientConnectionKeepalive\) that replace the previous connection initialization methods. Users now manage client connections through a unified object that handles automatic reconnection, idle timeouts, and keepalive pings according to gRPC specifications. This change includes new APIs for configuring TLS settings, custom error delegates, and request ID providers, fundamentally altering how clients are instantiated and configured.

Sources/GRPC · high confidence

The server call context API has been updated to include a \closeFuture\ property, allowing users to register callbacks for resource cleanup when an RPC completes, and a \UserInfo\ dictionary that is shared across interceptor contexts for passing data between them. Additionally, the \compressionEnabled\ flag and \trailers\ are now explicitly exposed on the base context with thread-safety guarantees enforced via event-loop assertions, and the \UserInfo\ type is now a heterotyped dictionary accessible to both service handlers and interceptors.

Sources/GRPC/ServerCallContexts · high confidence

The generated Swift files for the gRPC interoperability test models (including message definitions and client protocols) have been regenerated. This update aligns the generated code with the latest SwiftProtobuf API version (version 2), ensures generated types conform to \Sendable\ for concurrency safety, and incorporates the \swift-format-ignore-file\ directive to prevent automatic reformatting of these auto-generated sources.

Sources/GRPCInteroperabilityTestModels/Generated · high confidence

The CgRPC package has removed its legacy Makefile and module.modulemap files. This change eliminates the manual build process that previously compiled the CgRPC shared library (libCgRPC.so) using clang and installed it to system paths, as well as the explicit module map configuration. This aligns with the broader project shift to using Swift Package Manager for building and dependency management.

Packages/CgRPC · high confidence

The legacy gRPC iOS framework bundle files, specifically Info.plist and gRPC.h, have been removed from the project. This cleanup eliminates redundant metadata and header definitions that are no longer required, as the framework is now managed through the generated SwiftGRPC.xcodeproj.

gRPC · high confidence

The repository has been restructured to reflect its status as the maintenance branch for gRPC Swift 1, with the README explicitly directing users to grpc-swift-2 for the current major version. The project license has been changed from the original BSD-style license to Apache 2.0, and ownership has been updated to the gRPC Authors. Additionally, the repository now includes standard governance files (CODE-OF-CONDUCT, GOVERNANCE, MAINTAINERS, SECURITY, PATENTS, NOTICES) and configuration files (.editorconfig, .swift-format, .spi.yml) to support community contributions and documentation generation.

(repo-wide) · high confidence

The sample data used for testing gRPC connections has been refreshed with new, valid certificates and private keys. This change ensures that local development and test environments using these sample credentials (such as the CA, server, and client certificates) do not fail due to expiration, maintaining reliable mTLS and TLS test coverage.

Sources/GRPCSampleData · high confidence

The \protoc-gen-grpc-swift\ plugin now exclusively generates v1-style gRPC stubs. The previous v2 code generation path has been removed, and the plugin entry point (\GenerateGRPC\) now delegates all client and server stub generation to the v1 implementation (\generateV1Stubs\). Users relying on the v2 code generation mode will no longer receive generated code from this plugin.

Sources/protoc-gen-grpc-swift · high confidence

Add allocation counting tests for full RPC flows; Add code generation tests for gRPC-Swift plugin; Added async/await test suite for gRPC client and server interactions; Added fuzzing failure test cases for HTTP/2 parsing edge cases; Added gRPC interoperability test protocol definitions; Added generated test code for gRPC reflection v1alpha service; Added integration and unit tests for the gRPC Reflection Service; Added test suite for gRPC client and server functionality; Added tests for codegen serialization of file descriptors; Added tests for gRPC codegen method name normalization; Added tests for the gRPC connection pool and its delegates; Added unit tests for the async server handler state machine; Added unit tests for the gRPC Health service; Added unit tests for the server interceptor state machine.

This change updates the minimum versions of several core dependencies in the main Package.swift, including swift-nio (2.65.0), swift-nio-http2 (1.36.0), swift-nio-transport-services (1.24.0), swift-nio-extras (1.24.0), swift-collections (1.0.5), swift-atomics (1.2.0), swift-protobuf (1.31.0), swift-log (1.4.4), swift-argument-parser (1.1.1), and swift-nio-ssl (2.23.0). It also introduces a new FuzzTesting package for server fuzzing and updates the QPSBenchmark package to use newer dependency versions. Additionally, it removes several legacy Package.swift files from the Packages directory (CgRPC, Client, Server, gRPC) as part of the project's structural reorganization.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 47 → 49 (+1.6)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 93 → 93 (-0.1)
• Architecture 96 → 94 (-1.7)
• Maturity 57 → 57 (+0.0)
• Readiness 32 → 41 (+9.2)
• Security 42 → 42 (+0.0)
• Performance 62 (new)

• Off-boarding risk: anonymized user #1

• Coverage not measured — Swift suite
• Dependency hygiene PARTLY measured — SwiftPM pinning read, dependency currency NOT established
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (12 lines × 2) (Sources/GRPCInteroperabilityTestsImplementation/TestServiceAsyncProvider.swift)
• Duplicated block (12 lines × 2) (Sources/protoc-gen-grpc-swift/Generator-Client.swift)
• Duplicated block (9 lines × 2) (Examples/v1/RouteGuide/Client/RouteGuideClient.swift)
• Flaky test: .::GRPCTests.AcceptedServerTests.testGracefulShutdownOfServer
• Flaky test: .::GRPCTests.ClientConnectionBackoffTests.testClientConnectionFailsWithNoBackoff
• Flaky test: .::GRPCTests.ClientConnectionBackoffTests.testClientReconnectsAutomatically
• Flaky test: .::GRPCTests.ClientQuiescingTests.testInitiateShutdownWithPastDeadline_channelPool
• Flaky test: .::GRPCTests.ClientQuiescingTests.testQuiescingTimesOutAndFailsExistingRPC_clientConnection
• Flaky test: .::GRPCTests.ClientQuiescingTests.testQuiescingTimesOutAndFailsWaiters_channelPool
• Flaky test: .::GRPCTests.ClientQuiescingTests.testQuiescingWithNoOutstandingRPCs_channelPool
• Flaky test: .::GRPCTests.ClientQuiescingTests.testQuiescingWithNoOutstandingRPCs_clientConnection
• Flaky test: .::GRPCTests.ClientQuiescingTests.testStartRPCAfterShutdownCompletes_clientConnection
• No Package.resolved committed (FuzzTesting/Package.swift)
• No Package.resolved committed (Performance/QPSBenchmark/Package.swift)
• Off-boarding risk: anonymized user #1
• Projects may be oversized for their cohesion

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

grpc/grpc-swift was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.