This is an automated email from the ASF dual-hosted git repository.

chaokunyang pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/fory.git


The following commit(s) were added to refs/heads/main by this push:
     new 5971ded1d feat(compiler): support C++ gRPC code generation (#3877)
5971ded1d is described below

commit 5971ded1da4a9b308620388546f581e7c90188df
Author: Peiyang He <[email protected]>
AuthorDate: Mon Aug 3 01:15:32 2026 +0800

    feat(compiler): support C++ gRPC code generation (#3877)
    
    ## Why?
    
    Support C++ gRPC code generation.
    
    ## What does this PR do?
    
    ### Overview
    
    This PR adds C++ gRPC code generation support.
    All unary, server-streaming, client-streaming, and bidirectional RPC
    types are supported.
    They integrate with gRPC C++ synchronous APIs.
    
    ### Fory-backed codec
    
    Generated gRPC code uses Fory as codec. Given that the codec is
    relatively small, it is generated directed within each
    `*_service_grpc.h`.
    On writes, codec moves serialized bytes into a gRPC `Slice`, avoiding an
    additional outbound payload copy. On reads, it uses a single
    `ByteBuffer` slice when possible and merges fragmented buffers only when
    necessary.
    
    ### Error-handling
    
    To make the logic more robust, this PR also adds gRPC-related naming
    collision detection and escaping.
    This PR also considers special characters of C++ such as compilation
    guards.
    Generated model and service headers use sanitized include guards;
    the shared Fory codec is protected by
    `FORY_GENERATED_GRPC_SERIALIZATION_TRAITS_`;
    each `grpc::SerializationTraits<T>` specialization has a stable,
    type-specific guard derived from a sanitized fully qualified type name
    and a SHA-256 prefix. This prevents duplicate specializations when
    several generated service headers use the same message type.
    
    ### Testing
    
    This PR adds compiler-side pytests and C++-Java gRPC interop tests. It
    also adds a dedicated job in the CI.
    
    ### Documentation
    
    This PR adds documentation for the usage and example of the C++ gRPC
    code generation feature.
    
    
    ## Related issues
    
    Close https://github.com/apache/fory/issues/3276.
    
    ## AI Contribution Checklist
    
    - [ ] Substantial AI assistance was used in this PR: `yes` / `no`
    - [ ] If `yes`, I included a completed [AI Contribution
    
Checklist](https://github.com/apache/fory/blob/main/AI_POLICY.md#9-contributor-checklist-for-ai-assisted-prs)
    in this PR description and the required `AI Usage Disclosure`.
    - [ ] If `yes`, my PR description includes the required `ai_review`
    summary and screenshot evidence or equivalent persisted links of the
    final clean AI review results from both fresh reviewers described in
    `AI_POLICY.md`, the Fory-guided reviewer and the independent general
    reviewer, on the current PR diff or current HEAD after the latest code
    changes.
    
    
    ## Does this PR introduce any user-facing change?
    
    N/A.
    
    ## Benchmark
    
    N/A.
---
 .github/workflows/ci.yml                           |  45 ++
 compiler/README.md                                 |   3 +-
 compiler/fory_compiler/generators/cpp.py           |  44 +-
 compiler/fory_compiler/generators/rust.py          |  22 +-
 compiler/fory_compiler/generators/services/cpp.py  | 854 +++++++++++++++++++++
 compiler/fory_compiler/generators/services/rust.py |  28 +-
 .../fory_compiler/tests/test_service_codegen.py    | 455 +++++++++++
 cpp/CMakeLists.txt                                 |   1 +
 docs/compiler/compiler-guide.md                    |   7 +-
 docs/compiler/generated-code.md                    |  50 ++
 docs/compiler/index.md                             |  26 +-
 docs/guide/cpp/grpc-support.md                     | 277 +++++++
 docs/guide/cpp/index.md                            |   1 +
 integration_tests/grpc_tests/cpp/CMakeLists.txt    |  56 ++
 integration_tests/grpc_tests/cpp/interop/main.cc   | 769 +++++++++++++++++++
 integration_tests/grpc_tests/generate_grpc.py      |   2 +
 .../org/apache/fory/grpc_tests/CppGrpcTest.java    |  62 ++
 integration_tests/grpc_tests/run_tests.sh          |   6 +-
 18 files changed, 2659 insertions(+), 49 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 450bd1a73..db809611b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -879,6 +879,51 @@ jobs:
           cd integration_tests/grpc_tests/java
           mvn -T16 --no-transfer-progress -Dtest=RustGrpcTest test
 
+  grpc_java_cpp_tests:
+    name: Java/C++ gRPC Tests
+    needs: changes
+    if: >
+      needs.changes.outputs.grpc_tests == 'true' ||
+      needs.changes.outputs.cpp_code == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - name: Set up JDK 21
+        uses: actions/setup-java@v4
+        with:
+          java-version: 21
+          distribution: "temurin"
+      - name: Set up Python 3.11
+        uses: actions/setup-python@v5
+        with:
+          python-version: 3.11
+          cache: "pip"
+      - name: Install gRPC C++ development package
+        run: |
+          sudo apt-get update
+          sudo apt-get install --yes libgrpc++-dev protobuf-compiler-grpc
+      - name: Cache Maven local repository
+        uses: actions/cache@v4
+        with:
+          path: ~/.m2/repository
+          key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
+          restore-keys: |
+            ${{ runner.os }}-maven-
+      - name: Install Java artifacts for gRPC tests
+        run: |
+          cd java
+          mvn -T16 --no-transfer-progress clean install -DskipTests 
-Dmaven.javadoc.skip=true -Dmaven.source.skip=true
+      - name: Generate gRPC test sources
+        run: python integration_tests/grpc_tests/generate_grpc.py
+      - name: Build C++ gRPC peer
+        run: |
+          cmake -S integration_tests/grpc_tests/cpp -B 
integration_tests/grpc_tests/cpp/build -DCMAKE_BUILD_TYPE=Release
+          cmake --build integration_tests/grpc_tests/cpp/build --parallel
+      - name: Run Java/C++ gRPC tests
+        run: |
+          cd integration_tests/grpc_tests/java
+          mvn -T16 --no-transfer-progress -Dtest=CppGrpcTest test
+
   grpc_java_kotlin_tests:
     name: Java/Kotlin gRPC Tests
     needs: changes
diff --git a/compiler/README.md b/compiler/README.md
index 2fb48b3a2..d7eebb98e 100644
--- a/compiler/README.md
+++ b/compiler/README.md
@@ -10,7 +10,7 @@ The FDL compiler generates cross-language serialization code 
from schema definit
 - **Type ID and namespace support**: Both numeric IDs and name-based type 
registration
 - **Field modifiers**: Optional fields, reference tracking, list fields, 
scalar encoding modifiers
 - **File imports**: Modular schemas with import support
-- **gRPC service generation**: Native gRPC stubs and service bases for Java, 
Python, Go, Rust, C#, JavaScript, Dart, Kotlin, and Scala
+- **gRPC service generation**: Native gRPC stubs and service bases for Java, 
Python, Go, Rust, C++, C#, JavaScript, Dart, Kotlin, and Scala
 
 ## Documentation
 
@@ -335,6 +335,7 @@ fory_compiler/
         ├── python.py     # Python gRPC companion module (grpcio style)
         ├── go.py         # Go gRPC stub generator (google.golang.org/grpc)
         ├── rust.py       # Rust gRPC service module (tonic style)
+        ├── cpp.py        # C++ synchronous gRPC service companions
         ├── csharp.py     # C# gRPC service companion (Grpc.Core style)
         ├── javascript.py # JavaScript Node.js and gRPC-Web client generators
         ├── dart.py       # Dart gRPC service companion
diff --git a/compiler/fory_compiler/generators/cpp.py 
b/compiler/fory_compiler/generators/cpp.py
index 4d9d6a937..cc98b2d9d 100644
--- a/compiler/fory_compiler/generators/cpp.py
+++ b/compiler/fory_compiler/generators/cpp.py
@@ -17,11 +17,13 @@
 
 """C++ code generator."""
 
+import re
 from pathlib import Path
 from typing import Dict, List, Optional, Set, Tuple
 import typing
 
 from fory_compiler.generators.base import BaseGenerator, GeneratedFile
+from fory_compiler.generators.services.cpp import CppServiceGeneratorMixin
 from fory_compiler.frontend.utils import parse_idl_file
 from fory_compiler.ir.ast import (
     Message,
@@ -39,7 +41,7 @@ from fory_compiler.ir.ast import (
 from fory_compiler.ir.types import PrimitiveKind
 
 
-class CppGenerator(BaseGenerator):
+class CppGenerator(CppServiceGeneratorMixin, BaseGenerator):
     """Generates C++ classes with FORY_STRUCT macros."""
 
     language_name = "cpp"
@@ -741,7 +743,7 @@ class CppGenerator(BaseGenerator):
     def _ensure_name_caches(self, schema: Schema) -> None:
         """Construct the naming caches once for a schema file."""
         if not hasattr(self, "_named_schema_ids"):
-            # Init everything.
+            # We don't initialize cache for gRPC code generation here.
             self._named_schema_ids: Set[int] = set()
             self._type_identifier_cache: Dict[Tuple[object, ...], str] = {}
             self._field_identifier_cache: Dict[
@@ -883,12 +885,19 @@ class CppGenerator(BaseGenerator):
         lines.append(f"{indent}  return 
{detail}::get_fory().serialize(*this);")
         lines.append(f"{indent}}}")
         lines.append("")
+        # gRPC payload deserialization would require this.
         lines.append(
-            f"{indent}static ::fory::Result<{class_name}, ::fory::Error> 
from_bytes(const ::std::vector<::uint8_t>& data) {{"
+            f"{indent}static ::fory::Result<{class_name}, ::fory::Error> 
from_bytes(const ::uint8_t* data, ::std::size_t size) {{"
+        )
+        lines.append(
+            f"{indent}  return 
{detail}::get_fory().deserialize<{class_name}>(data, size);"
         )
+        lines.append(f"{indent}}}")
+        lines.append("")
         lines.append(
-            f"{indent}  return 
{detail}::get_fory().deserialize<{class_name}>(data);"
+            f"{indent}static ::fory::Result<{class_name}, ::fory::Error> 
from_bytes(const ::std::vector<::uint8_t>& data) {{"
         )
+        lines.append(f"{indent}  return from_bytes(data.data(), data.size());")
         lines.append(f"{indent}}}")
         return lines
 
@@ -911,7 +920,7 @@ class CppGenerator(BaseGenerator):
         includes.add("<utility>")
         includes.add('"fory/serialization/fory.h"')
         if self.schema_has_unions():
-            includes.add("<cstddef>")  # todo: what's this??
+            includes.add("<cstddef>")
             includes.add("<utility>")
             includes.add("<variant>")
             includes.add("<memory>")
@@ -936,14 +945,11 @@ class CppGenerator(BaseGenerator):
             self.collect_union_includes(union, includes)
 
         # License header
-        lines.append("/*")
-        for line in self.get_license_header(" *").split("\n"):
-            lines.append(line)
-        lines.append(" */")
+        lines.extend(self._cpp_license_lines())
         lines.append("")
 
         # Header guard
-        guard_name = f"{self.get_header_name().upper()}_H_"
+        guard_name = self._cpp_header_guard(f"{self.get_header_name()}.h")
         lines.append(f"#ifndef {guard_name}")
         lines.append(f"#define {guard_name}")
         lines.append("")
@@ -1024,6 +1030,24 @@ class CppGenerator(BaseGenerator):
             content="\n".join(lines),
         )
 
+    def _cpp_license_lines(self) -> List[str]:
+        """Generate the Apache license block for generated C++ files."""
+        lines = ["/*"]
+        lines.extend(self.get_license_header(" *").split("\n"))
+        lines.append(" */")
+        return lines
+
+    def _cpp_header_guard(self, path: str) -> str:
+        """Generate a header guard name for a path."""
+        # Header names can contain '.', '-', '/', or other characters outside
+        # the conservative ASCII macro identifier set used by generated 
headers.
+        return re.sub(r"[^A-Za-z0-9]", "_", path).upper() + "_"
+
+    def indent_lines(self, lines: List[str], level: int) -> List[str]:
+        """Indent a list of lines by the given level."""
+        prefix = "  " * level  # C++ uses two-spaces style.
+        return [f"{prefix}{line}" if line else line for line in lines]
+
     def collect_message_includes(self, message: Message, includes: Set[str]):
         """Collect includes for a message and its nested types recursively."""
         for field in message.fields:
diff --git a/compiler/fory_compiler/generators/rust.py 
b/compiler/fory_compiler/generators/rust.py
index 5c7e8a949..214db5b2a 100644
--- a/compiler/fory_compiler/generators/rust.py
+++ b/compiler/fory_compiler/generators/rust.py
@@ -416,7 +416,7 @@ class RustGenerator(RustServiceGeneratorMixin, 
BaseGenerator):
     def _ensure_name_caches(self, schema: Schema) -> None:
         """Construct the naming caches once for a schema file."""
         if not hasattr(self, "_named_schema_ids"):
-            # Init everything.
+            # Rust gRPC naming caches are initialized by the service generator.
             self._named_schema_ids: set[int] = set()
             self._type_identifier_cache: dict[tuple[object, ...], str] = {}
             self._module_identifier_cache: dict[tuple[object, ...], str] = {}
@@ -429,26 +429,6 @@ class RustGenerator(RustServiceGeneratorMixin, 
BaseGenerator):
             self._union_case_identifier_cache: dict[
                 tuple[object, ...], dict[tuple[object, ...], str]
             ] = {}
-            self._named_service_schema_ids: set[int] = set()
-            self._service_trait_identifier_cache: dict[tuple[object, ...], 
str] = {}
-            self._service_client_module_identifier_cache: dict[
-                tuple[object, ...], str
-            ] = {}
-            self._service_server_module_identifier_cache: dict[
-                tuple[object, ...], str
-            ] = {}
-            self._service_name_constant_identifier_cache: dict[
-                tuple[object, ...], str
-            ] = {}
-            self._rpc_method_identifier_cache: dict[
-                tuple[object, ...], dict[tuple[object, ...], str]
-            ] = {}
-            self._rpc_stream_type_identifier_cache: dict[
-                tuple[object, ...], dict[tuple[object, ...], str]
-            ] = {}
-            self._rpc_path_constant_identifier_cache: dict[
-                tuple[object, ...], dict[tuple[object, ...], str]
-            ] = {}
         schema_id = id(schema)
         if schema_id in self._named_schema_ids:
             # Cache exists.
diff --git a/compiler/fory_compiler/generators/services/cpp.py 
b/compiler/fory_compiler/generators/services/cpp.py
new file mode 100644
index 000000000..bfbe380a0
--- /dev/null
+++ b/compiler/fory_compiler/generators/services/cpp.py
@@ -0,0 +1,854 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""C++ gRPC service generator helpers."""
+
+import hashlib
+import re
+from typing import Dict, List, Set, Tuple
+
+from fory_compiler.generators.base import GeneratedFile
+from fory_compiler.generators.services.base import StreamingMode, 
streaming_mode
+from fory_compiler.ir.ast import NamedType, RpcMethod, Service
+
+
+class CppServiceGeneratorMixin:
+    """Generates C++ gRPC service companions."""
+
+    def generate_services(self) -> List[GeneratedFile]:
+        """Generate C++ gRPC service companion module."""
+        local_services = [
+            service
+            for service in self.schema.services
+            if not self.is_imported_type(service)
+        ]
+        if not local_services:
+            return []
+        self.allocate_grpc_service_identifiers(local_services)
+        return [
+            self.generate_service_api_header(local_services),
+            self.generate_service_grpc_header(local_services),
+            self.generate_service_grpc_source(local_services),
+        ]
+
+    def allocate_grpc_service_identifiers(self, services: List[Service]) -> 
None:
+        """Allocate sanitized identifiers used by generated gRPC code."""
+        self._ensure_name_caches(self.schema)
+        # gRPC headers own ::grpc, so a colliding root package must be 
rejected.
+        if self.package and self.get_namespace().split("::", 1)[0] == "grpc":
+            raise ValueError(
+                "C++ name collision in global C++ namespace: "
+                f"gRPC root namespace and package {self.package!r} both map "
+                "to C++ identifier 'grpc'"
+            )
+        if not hasattr(self, "_named_service_schema_ids"):
+            self._named_service_schema_ids: Set[int] = set()
+            self._service_interface_identifier_cache: Dict[Tuple[object, ...], 
str] = {}
+            self._service_stub_identifier_cache: Dict[Tuple[object, ...], str] 
= {}
+            self._service_grpc_identifier_cache: Dict[Tuple[object, ...], str] 
= {}
+            self._service_name_constant_identifier_cache: Dict[
+                Tuple[object, ...], str
+            ] = {}
+            self._rpc_method_identifier_cache: Dict[
+                Tuple[object, ...], Dict[Tuple[object, ...], str]
+            ] = {}
+            self._rpc_path_constant_identifier_cache: Dict[
+                Tuple[object, ...], Dict[Tuple[object, ...], str]
+            ] = {}
+            self._rpc_method_member_identifier_cache: Dict[
+                Tuple[object, ...], Dict[Tuple[object, ...], str]
+            ] = {}
+
+        schema_id = id(self.schema)
+        if schema_id in self._named_service_schema_ids:
+            return
+
+        # Reserve the fixed service companion namespace in the schema scope.
+        # e.g.:
+        #
+        #   namespace demo;
+        #
+        #   message service {
+        #     string name = 1;
+        #   }
+        #
+        #   service Greeter {
+        #     rpc SayHello (service) returns (service);
+        #   }
+        #
+        # This IDL itself is valid. But in our design, both `message service`
+        # and `service Greeter` would take up the same `::demo::service` 
namespace.
+        # We should detect this kind of collision and throw errors to the user.
+        used_schema_names: Dict[str, str] = {}
+        if not self.package:
+            used_schema_names["grpc"] = "gRPC root namespace"
+        for type_def in self.schema.enums + self.schema.unions + 
self.schema.messages:
+            if not self.is_imported_type(type_def):
+                self._allocate_scoped_identifier(
+                    self.get_type_identifier(type_def),
+                    used_schema_names,
+                    "C++ gRPC schema namespace",
+                    f"model type {type_def.name!r}",
+                )
+        self._allocate_scoped_identifier(
+            "service",
+            used_schema_names,
+            "C++ gRPC schema namespace",
+            "generated service namespace",
+        )
+        # For package name `demo`,
+        # `used_service_names` checks collisions under `demo::service`,
+        # `used_grpc_names` checks collisions under `demo::service::grpc`.
+        used_service_names: Dict[str, str] = {}
+        self._allocate_scoped_identifier(
+            "grpc",
+            used_service_names,
+            "C++ gRPC service namespace",
+            "generated gRPC transport namespace",
+        )
+        used_grpc_names: Dict[str, str] = {}
+        for service in services:
+            service_key = self._cache_key(service)
+            self._service_interface_identifier_cache[service_key] = (
+                self._allocate_scoped_identifier(
+                    service.name,
+                    used_service_names,
+                    "C++ gRPC service namespace",
+                    f"service interface {service.name}",
+                )
+            )
+            self._service_stub_identifier_cache[service_key] = (
+                self._allocate_scoped_identifier(
+                    f"{service.name}Stub",
+                    used_grpc_names,
+                    "C++ gRPC transport namespace",
+                    f"service stub {service.name}",
+                )
+            )
+            self._service_grpc_identifier_cache[service_key] = (
+                self._allocate_scoped_identifier(
+                    f"{service.name}ServiceGrpc",
+                    used_grpc_names,
+                    "C++ gRPC transport namespace",
+                    f"gRPC service wrapper {service.name}",
+                )
+            )
+            self._service_name_constant_identifier_cache[service_key] = (
+                self._allocate_scoped_identifier(
+                    f"{self.to_pascal_case(service.name)}ServiceName",
+                    used_service_names,
+                    "C++ gRPC service namespace",
+                    f"service name constant for {service.name}",
+                )
+            )
+            stub_name = self._service_stub_identifier_cache[service_key]
+            interface_name = 
self._service_interface_identifier_cache[service_key]
+
+            # Even though C++ allows function overloading, at IDL level, 
method names in the same service cannot be identical,
+            # since gRPC relies on their names to locate the handler.
+            used_methods: Dict[str, str] = {}
+            used_members: Dict[str, str] = {}
+            reserved_method_names = {interface_name, stub_name}
+            method_names: Dict[Tuple[object, ...], str] = {}
+            path_constants: Dict[Tuple[object, ...], str] = {}
+            rpc_members: Dict[Tuple[object, ...], str] = {}
+            for method in service.methods:
+                method_key = self._cache_key(method)
+                method_names[method_key] = self._allocate_scoped_identifier(
+                    method.name,
+                    used_methods,
+                    f"C++ gRPC service {service.name} methods",
+                    method.name,
+                    reserved_names=reserved_method_names,
+                )
+                method_name = method_names[method_key]
+                # Client stub code uses `channel_` as a data member name.
+                if method_name == "channel_" or method_name in used_members:
+                    raise ValueError(
+                        f"C++ name collision in gRPC stub {stub_name}: method "
+                        f"{method.name!r} conflicts with member 
{method_name!r}"
+                    )
+                used_members[method_name] = method.name
+                rpc_members[method_key] = self._allocate_scoped_identifier(
+                    f"rpcmethod_{method_name}_",
+                    used_members,
+                    f"C++ gRPC stub {stub_name} members",
+                    f"RPC method member for {service.name}.{method.name}",
+                )
+                path_constants[method_key] = self._allocate_scoped_identifier(
+                    f"{self.to_pascal_case(service.name)}"
+                    f"{self.to_pascal_case(method.name)}Path",
+                    used_service_names,
+                    "C++ gRPC service namespace",
+                    f"RPC path constant for {service.name}.{method.name}",
+                )
+            self._rpc_method_identifier_cache[service_key] = method_names
+            self._rpc_method_member_identifier_cache[service_key] = rpc_members
+            self._rpc_path_constant_identifier_cache[service_key] = 
path_constants
+
+        self._named_service_schema_ids.add(schema_id)
+
+    def generate_service_api_header(self, services: List[Service]) -> 
GeneratedFile:
+        """Generate C++ service API header file (service.h)."""
+        path = f"{self.get_header_name()}.service.h"
+        guard = self._cpp_header_guard(path)
+        lines = self._cpp_license_lines()
+        lines.extend(
+            [
+                "",
+                f"#ifndef {guard}",
+                f"#define {guard}",
+                "",
+                f'#include "{self.get_header_name()}.h"',
+                "",
+                "#include <grpcpp/server_context.h>",
+                "#include <grpcpp/support/status.h>",
+                "#include <grpcpp/support/sync_stream.h>",
+                "",
+            ]
+        )
+        service_namespace = self.service_namespace()
+        lines.extend([f"namespace {service_namespace} {{", ""])
+        for i, service in enumerate(services):
+            if i > 0:
+                lines.append("")
+            lines.extend(self.generate_service_interface(service))
+            lines.append("")
+            lines.extend(self.generate_service_constants(service))
+        lines.extend(["", f"}}  // namespace {service_namespace}"])
+        lines.extend(["", f"#endif  // {guard}", ""])  # End header guard.
+        return GeneratedFile(path=path, content="\n".join(lines))
+
+    def generate_service_interface(self, service: Service) -> List[str]:
+        """Generate gRPC service interface."""
+        service_key = self._cache_key(service)
+        interface_name = self._service_interface_identifier_cache[service_key]
+        lines = [
+            f"class {interface_name} {{",
+            " public:",
+        ]
+        lines.extend(self.indent_lines([f"virtual ~{interface_name}() = 
default;"], 1))
+        for i, method in enumerate(service.methods):
+            if i > 0:
+                lines.append("")
+            lines.extend(
+                self.indent_lines(
+                    self.generate_grpc_method_signature(service, method), 1
+                )
+            )
+        lines.append("};")
+        return lines
+
+    def generate_grpc_method_signature(
+        self, service: Service, method: RpcMethod
+    ) -> List[str]:
+        """Generate gRPC service trait method signature."""
+        service_key = self._cache_key(service)
+        method_key = self._cache_key(method)
+        method_name = 
self._rpc_method_identifier_cache[service_key][method_key]
+        request_type = self.service_type_path(method.request_type)
+        response_type = self.service_type_path(method.response_type)
+        mode = streaming_mode(method)
+        lines = [f"virtual ::grpc::Status {method_name}("]
+        if mode == StreamingMode.UNARY:
+            lines.extend(
+                [
+                    "    ::grpc::ServerContext* context,",
+                    f"    const {request_type}* request,",
+                    f"    {response_type}* response) = 0;",
+                ]
+            )
+        elif mode == StreamingMode.CLIENT_STREAMING:
+            lines.extend(
+                [
+                    "    ::grpc::ServerContext* context,",
+                    f"    ::grpc::ServerReader<{request_type}>* reader,",
+                    f"    {response_type}* response) = 0;",
+                ]
+            )
+        elif mode == StreamingMode.SERVER_STREAMING:
+            lines.extend(
+                [
+                    "    ::grpc::ServerContext* context,",
+                    f"    const {request_type}* request,",
+                    f"    ::grpc::ServerWriter<{response_type}>* writer) = 0;",
+                ]
+            )
+        else:
+            lines.extend(
+                [
+                    "    ::grpc::ServerContext* context,",
+                    "    ::grpc::ServerReaderWriter<",
+                    f"        {response_type}, {request_type}>* stream) = 0;",
+                ]
+            )
+        return lines
+
+    def service_type_path(self, named_type: NamedType) -> str:
+        """Get C++ path for a gRPC request or response type."""
+        resolved = self.schema.get_type(named_type.name)
+        if resolved is None:
+            raise ValueError(f"Unknown gRPC message type {named_type.name!r}")
+        return self.generate_namespaced_type(
+            named_type, parent_stack=None, global_qualify=True
+        )
+
+    def generate_service_constants(self, service: Service) -> List[str]:
+        """Generate service and gRPC path constants."""
+        lines: List[str] = []
+        service_key = self._cache_key(service)
+        service_name_const = 
self._service_name_constant_identifier_cache[service_key]
+        service_name = self.get_grpc_service_name(service)
+        lines.append(
+            f'inline constexpr char {service_name_const}[] = "{service_name}";'
+        )
+        for method in service.methods:
+            method_key = self._cache_key(method)
+            rpc_path_const = 
self._rpc_path_constant_identifier_cache[service_key][
+                method_key
+            ]
+            lines.append(
+                f"inline constexpr char {rpc_path_const}[] = "
+                f'"{self.get_grpc_method_path(service, method)}";'
+            )
+        return lines
+
+    def generate_service_grpc_header(self, services: List[Service]) -> 
GeneratedFile:
+        """Generate C++ service transport binding header file 
(service.grpc.h)."""
+        path = f"{self.get_header_name()}.service.grpc.h"
+        guard = self._cpp_header_guard(path)
+        lines = self._cpp_license_lines()
+        lines.extend(
+            [
+                "",
+                f"#ifndef {guard}",
+                f"#define {guard}",
+                "",
+                f'#include "{self.get_header_name()}.service.h"',
+                "",
+                "#include <cstddef>",
+                "#include <cstdint>",
+                "#include <memory>",
+                "#include <utility>",
+                "#include <vector>",
+                "",
+                "#include <grpcpp/channel.h>",
+                "#include <grpcpp/client_context.h>",
+                "#include <grpcpp/impl/rpc_method.h>",
+                "#include <grpcpp/impl/serialization_traits.h>",
+                "#include <grpcpp/impl/service_type.h>",
+                "#include <grpcpp/support/byte_buffer.h>",
+                "#include <grpcpp/support/slice.h>",
+                "#include <grpcpp/support/status.h>",
+                "#include <grpcpp/support/stub_options.h>",
+                "#include <grpcpp/support/sync_stream.h>",
+                "",
+            ]
+        )
+        lines.extend(self.generate_grpc_codec())
+        payload_impls = self.generate_grpc_payload_impls(services)
+        if payload_impls:
+            lines.append("")
+            lines.extend(payload_impls)
+        grpc_namespace = f"{self.service_namespace()}::grpc"
+        lines.extend(["", f"namespace {grpc_namespace} {{"])
+        for service in services:
+            lines.append("")
+            lines.extend(self.generate_grpc_client_declaration(service))
+            lines.append("")
+            lines.extend(self.generate_grpc_server_declaration(service))
+        lines.extend(["", f"}}  // namespace {grpc_namespace}"])
+        lines.extend(["", f"#endif  // {guard}", ""])  # End header guard.
+        return GeneratedFile(path=path, content="\n".join(lines))
+
+    def generate_grpc_codec(self) -> List[str]:
+        """Generate Fory-backed codec used by C++ gRPC stubs, instead of 
relying on a separate file."""
+        return [
+            "#ifndef FORY_GENERATED_GRPC_SERIALIZATION_TRAITS_",
+            "#define FORY_GENERATED_GRPC_SERIALIZATION_TRAITS_",
+            "",
+            "namespace fory::grpc::detail {",
+            "",
+            "template <class Message, auto GetFory>",
+            "class ForyGrpcSerializationTraits {",
+            " public:",
+            "  static ::grpc::Status Serialize(const Message& message,",
+            "                                  ::grpc::ByteBuffer* buffer,",
+            "                                  bool* own_buffer) {",
+            "    if (buffer == nullptr || own_buffer == nullptr) {",
+            "      return ::grpc::Status(::grpc::StatusCode::INTERNAL,",
+            '                            "Missing gRPC serialization 
output");',
+            "    }",
+            # gRPC reads own_buffer even when serialization returns an error
+            # so we should initialize own_buffer before fallible serialization.
+            "    *own_buffer = true;",
+            "    auto* bytes = new ::std::vector<::uint8_t>();",
+            "    auto result = GetFory().serialize_to(*bytes, message);",
+            "    if (!result.ok()) {",
+            "      delete bytes;",
+            "      return ::grpc::Status(::grpc::StatusCode::INTERNAL,",
+            "                            result.error().to_string());",
+            "    }",
+            "    ::grpc::Slice slice;",
+            "    if (bytes->empty()) {",
+            "      delete bytes;",
+            "      slice = ::grpc::Slice(0);",
+            "    } else {",
+            "      slice = ::grpc::Slice(bytes->data(), bytes->size(),",
+            "                            
&ForyGrpcSerializationTraits::DestroyBytes,",
+            "                            bytes);",
+            "    }",
+            "    ::grpc::ByteBuffer encoded(&slice, 1);",
+            "    buffer->Swap(&encoded);",
+            "    return ::grpc::Status::OK;",
+            "  }",
+            "",
+            "  static ::grpc::Status Deserialize(::grpc::ByteBuffer* buffer,",
+            "                                    Message* message) {",
+            "    if (buffer == nullptr || message == nullptr || 
!buffer->Valid()) {",
+            "      return ::grpc::Status(::grpc::StatusCode::INTERNAL,",
+            '                            "Missing gRPC message bytes");',
+            "    }",
+            "    ::grpc::Slice slice;",
+            "    auto status = buffer->TrySingleSlice(&slice);",
+            "    if (!status.ok()) {",
+            "      status = buffer->DumpToSingleSlice(&slice);",
+            "      if (!status.ok()) {",
+            "        return status;",
+            "      }",
+            "    }",
+            "    auto result = Message::from_bytes(slice.begin(), 
slice.size());",
+            "    buffer->Clear();",
+            "    if (!result.ok()) {",
+            "      return ::grpc::Status(::grpc::StatusCode::INTERNAL,",
+            "                            result.error().to_string());",
+            "    }",
+            "    *message = ::std::move(result).value();",
+            "    return ::grpc::Status::OK;",
+            "  }",
+            "",
+            " private:",
+            "  static void DestroyBytes(void* data) {",
+            "    delete static_cast<::std::vector<::uint8_t>*>(data);",
+            "  }",
+            "};",
+            "",
+            "}  // namespace fory::grpc::detail",
+            "",
+            "#endif  // FORY_GENERATED_GRPC_SERIALIZATION_TRAITS_",
+        ]
+
+    def generate_grpc_payload_impls(self, services: List[Service]) -> 
List[str]:
+        """Generate `SerializationTraits` specializations for all gRPC payload 
types."""
+        lines: List[str] = []
+        for i, (type_path, get_fory_path) in enumerate(
+            self.grpc_payload_types(services)
+        ):
+            if i > 0:
+                lines.append("")
+            lines.extend(self.generate_grpc_payload_impl(type_path, 
get_fory_path))
+        return lines
+
+    def grpc_payload_types(self, services: List[Service]) -> List[Tuple[str, 
str]]:
+        """Get unique payload type and Fory accessor paths in service order."""
+        seen: Set[str] = set()
+        payload_types: List[Tuple[str, str]] = []
+        for service in services:
+            for method in service.methods:
+                for named_type in (method.request_type, method.response_type):
+                    type_path = self.service_type_path(named_type)
+                    if type_path in seen:
+                        continue
+                    seen.add(type_path)
+                    resolved = self.schema.get_type(named_type.name)
+                    if resolved is None:
+                        raise ValueError(
+                            f"Unknown gRPC message type {named_type.name!r}"
+                        )
+                    namespace = (
+                        self._namespace_for_type(resolved)
+                        if self.is_imported_type(resolved)
+                        else self.get_namespace()
+                    )
+                    detail = f"::{namespace}::detail" if namespace else 
"::detail"
+                    payload_types.append((type_path, f"&{detail}::get_fory"))
+        return payload_types
+
+    def generate_grpc_payload_impl(
+        self, type_path: str, get_fory_path: str
+    ) -> List[str]:
+        """Generate `SerializationTraits` specializations for one gRPC request 
or response type."""
+        # Each type-specific `grpc::SerializationTraits` specialization needs a
+        # stable include guard because the same payload type can be referenced 
by
+        # multiple generated service headers.
+        # See the test_cpp_grpc_shared_message_specialization_guard case in 
test_service_codegen.py as an example.
+        # C++ type paths such as `::demo::greeter::Hello` are not valid macro 
identifiers,
+        # so the guard uses a readable sanitized prefix like 
`DEMO_GREETER_HELLO` plus a digest
+        # of the original type path to avoid collisions.
+        readable = re.sub(r"[^A-Za-z0-9]+", "_", type_path).strip("_").upper()
+        # We use sha256 to compute the digest since its stability.
+        digest = 
hashlib.sha256(type_path.encode("utf-8")).hexdigest()[:12].upper()
+        guard = f"FORY_GENERATED_GRPC_TRAITS_{readable}_{digest}_"
+        return [
+            f"#ifndef {guard}",
+            f"#define {guard}",
+            "namespace grpc {",
+            "template <>",
+            f"class SerializationTraits<{type_path}, void>",
+            "    : public ::fory::grpc::detail::ForyGrpcSerializationTraits<",
+            f"          {type_path}, {get_fory_path}> {{}};",
+            "}  // namespace grpc",
+            f"#endif  // {guard}",
+        ]
+
+    def generate_service_grpc_source(self, services: List[Service]) -> 
GeneratedFile:
+        """Generate gRPC client and server transport definitions 
(service.grpc.cc)."""
+        path = f"{self.get_header_name()}.service.grpc.cc"
+        lines = self._cpp_license_lines()
+        lines.extend(
+            [
+                "",
+                f'#include "{self.get_header_name()}.service.grpc.h"',
+                "",
+                "#include <grpcpp/impl/client_unary_call.h>",
+                "#include <grpcpp/impl/rpc_service_method.h>",
+                "#include <grpcpp/support/method_handler.h>",
+                "",
+            ]
+        )
+        grpc_namespace = f"{self.service_namespace()}::grpc"
+        lines.extend([f"namespace {grpc_namespace} {{", ""])
+        for i, service in enumerate(services):
+            if i > 0:
+                lines.append("")
+            lines.extend(self.generate_grpc_client_definition(service))
+            lines.append("")
+            lines.extend(self.generate_grpc_server_definition(service))
+        lines.extend(["", f"}}  // namespace {grpc_namespace}"])
+        lines.append("")
+        return GeneratedFile(path=path, content="\n".join(lines))
+
+    def generate_grpc_client_declaration(self, service: Service) -> List[str]:
+        """Generate gRPC client declaration in service.grpc.h."""
+        service_key = self._cache_key(service)
+        stub_name = self._service_stub_identifier_cache[service_key]
+        lines = [
+            f"class {stub_name} final {{",
+            " public:",
+        ]
+        lines.extend(
+            self.indent_lines(
+                [
+                    f"static ::std::unique_ptr<{stub_name}> NewStub(",
+                    "    const ::std::shared_ptr<::grpc::ChannelInterface>& 
channel,",
+                    "    const ::grpc::StubOptions& options = 
::grpc::StubOptions());",
+                ],
+                1,
+            )
+        )
+        for method in service.methods:
+            lines.append("")
+            lines.extend(
+                self.indent_lines(
+                    self.generate_grpc_client_method_declaration(service, 
method), 1
+                )
+            )
+        lines.extend(
+            [
+                "",
+                " private:",
+            ]
+        )
+        lines.extend(
+            self.indent_lines(
+                [
+                    f"{stub_name}(",
+                    "    const ::std::shared_ptr<::grpc::ChannelInterface>& 
channel,",
+                    "    const ::grpc::StubOptions& options);",
+                ],
+                1,
+            )
+        )
+        lines.append("")
+        lines.extend(
+            self.indent_lines(
+                ["::std::shared_ptr<::grpc::ChannelInterface> channel_;"], 1
+            )
+        )
+        for method in service.methods:
+            member = self._rpc_method_member_identifier_cache[service_key][
+                self._cache_key(method)
+            ]
+            lines.extend(
+                self.indent_lines([f"::grpc::internal::RpcMethod {member};"], 
1)
+            )
+        lines.append("};")
+        return lines
+
+    def generate_grpc_client_definition(self, service: Service) -> List[str]:
+        """Generate gRPC client implementation in service.grpc.cc."""
+        service_key = self._cache_key(service)
+        stub_name = self._service_stub_identifier_cache[service_key]
+        lines = [
+            f"::std::unique_ptr<{stub_name}> {stub_name}::NewStub(",
+            "    const ::std::shared_ptr<::grpc::ChannelInterface>& channel,",
+            "    const ::grpc::StubOptions& options) {",
+            f"  return ::std::unique_ptr<{stub_name}>(new {stub_name}(channel, 
options));",
+            "}",
+            "",
+            f"{stub_name}::{stub_name}(",
+            "    const ::std::shared_ptr<::grpc::ChannelInterface>& channel,",
+            "    const ::grpc::StubOptions& options)",
+            f"    : channel_(channel){',' if service.methods else ''}",
+        ]
+        for i, method in enumerate(service.methods):
+            method_key = self._cache_key(method)
+            member = 
self._rpc_method_member_identifier_cache[service_key][method_key]
+            path_constant = self.service_path_constant_type_path(service, 
method)
+            method_type = self._grpc_method_type(method)
+            suffix = "," if i + 1 < len(service.methods) else ""
+            lines.extend(
+                [
+                    f"      {member}({path_constant}, 
options.suffix_for_stats(),",
+                    f"                 
::grpc::internal::RpcMethod::{method_type}, channel){suffix}",
+                ]
+            )
+        lines.append("{}")
+        for method in service.methods:
+            lines.append("")
+            lines.extend(self.generate_grpc_client_method_definition(service, 
method))
+        return lines
+
+    def generate_grpc_client_method_declaration(
+        self, service: Service, method: RpcMethod
+    ) -> List[str]:
+        """Generate gRPC client method declaration in service.grpc.h."""
+        service_key = self._cache_key(service)
+        method_name = self._rpc_method_identifier_cache[service_key][
+            self._cache_key(method)
+        ]
+        request_type = self.service_type_path(method.request_type)
+        response_type = self.service_type_path(method.response_type)
+        mode = streaming_mode(method)
+        if mode == StreamingMode.UNARY:
+            return [
+                f"::grpc::Status {method_name}(",
+                "    ::grpc::ClientContext* context,",
+                f"    const {request_type}& request, {response_type}* 
response);",
+            ]
+        if mode == StreamingMode.CLIENT_STREAMING:
+            return [
+                f"::std::unique_ptr<::grpc::ClientWriter<{request_type}>> 
{method_name}(",
+                "    ::grpc::ClientContext* context,",
+                f"    {response_type}* response);",
+            ]
+        if mode == StreamingMode.SERVER_STREAMING:
+            return [
+                f"::std::unique_ptr<::grpc::ClientReader<{response_type}>> 
{method_name}(",
+                "    ::grpc::ClientContext* context,",
+                f"    const {request_type}& request);",
+            ]
+        return [
+            "::std::unique_ptr<::grpc::ClientReaderWriter<",
+            f"    {request_type}, {response_type}>> {method_name}(",
+            "    ::grpc::ClientContext* context);",
+        ]
+
+    def generate_grpc_client_method_definition(
+        self, service: Service, method: RpcMethod
+    ) -> List[str]:
+        """Generate gRPC client method implementation in service.grpc.cc."""
+        service_key = self._cache_key(service)
+        method_key = self._cache_key(method)
+        stub_name = self._service_stub_identifier_cache[service_key]
+        method_name = 
self._rpc_method_identifier_cache[service_key][method_key]
+        member = 
self._rpc_method_member_identifier_cache[service_key][method_key]
+        request_type = self.service_type_path(method.request_type)
+        response_type = self.service_type_path(method.response_type)
+        mode = streaming_mode(method)
+        if mode == StreamingMode.UNARY:
+            return [
+                f"::grpc::Status {stub_name}::{method_name}(",
+                "    ::grpc::ClientContext* context,",
+                f"    const {request_type}& request, {response_type}* 
response) {{",
+                "  return ::grpc::internal::BlockingUnaryCall<",
+                f"      {request_type}, {response_type}>(",
+                f"      channel_.get(), {member}, context, request, 
response);",
+                "}",
+            ]
+        if mode == StreamingMode.CLIENT_STREAMING:
+            return [
+                f"::std::unique_ptr<::grpc::ClientWriter<{request_type}>>",
+                f"{stub_name}::{method_name}(::grpc::ClientContext* context,",
+                f"                         {response_type}* response) {{",
+                f"  return 
::std::unique_ptr<::grpc::ClientWriter<{request_type}>>(",
+                f"      
::grpc::internal::ClientWriterFactory<{request_type}>::Create(",
+                f"          channel_.get(), {member}, context, response));",
+                "}",
+            ]
+        if mode == StreamingMode.SERVER_STREAMING:
+            return [
+                f"::std::unique_ptr<::grpc::ClientReader<{response_type}>>",
+                f"{stub_name}::{method_name}(::grpc::ClientContext* context,",
+                f"                         const {request_type}& request) {{",
+                f"  return 
::std::unique_ptr<::grpc::ClientReader<{response_type}>>(",
+                f"      
::grpc::internal::ClientReaderFactory<{response_type}>::Create(",
+                f"          channel_.get(), {member}, context, request));",
+                "}",
+            ]
+        return [
+            "::std::unique_ptr<::grpc::ClientReaderWriter<",
+            f"    {request_type}, {response_type}>>",
+            f"{stub_name}::{method_name}(::grpc::ClientContext* context) {{",
+            "  return ::std::unique_ptr<::grpc::ClientReaderWriter<",
+            f"      {request_type}, {response_type}>>(",
+            "      ::grpc::internal::ClientReaderWriterFactory<",
+            f"          {request_type}, {response_type}>::Create(",
+            f"          channel_.get(), {member}, context));",
+            "}",
+        ]
+
+    def generate_grpc_server_declaration(self, service: Service) -> List[str]:
+        """Generate gRPC server declaration in service.grpc.h."""
+        service_key = self._cache_key(service)
+        interface_type = self.service_interface_type_path(service)
+        grpc_name = self._service_grpc_identifier_cache[service_key]
+        lines = [
+            f"class {grpc_name} final : public ::grpc::Service {{",
+            " public:",
+        ]
+        lines.extend(
+            self.indent_lines(
+                [
+                    "// The caller owns impl; it must outlive this adapter and 
server.",
+                    f"explicit {grpc_name}({interface_type}* impl);",
+                ],
+                1,
+            )
+        )
+        lines.extend(["", " private:"])
+        lines.extend(self.indent_lines([f"{interface_type}* impl_;"], 1))
+        lines.append("};")
+        return lines
+
+    def generate_grpc_server_definition(self, service: Service) -> List[str]:
+        """Generate gRPC server implementation in service.grpc.cc."""
+        service_key = self._cache_key(service)
+        interface_type = self.service_interface_type_path(service)
+        grpc_name = self._service_grpc_identifier_cache[service_key]
+        lines = [f"{grpc_name}::{grpc_name}({interface_type}* impl) : 
impl_(impl) {{"]
+        for method in service.methods:
+            lines.extend(
+                self.indent_lines(self.generate_grpc_server_route(service, 
method), 1)
+            )
+        lines.append("}")
+        return lines
+
+    def generate_grpc_server_route(
+        self, service: Service, method: RpcMethod
+    ) -> List[str]:
+        """Generate one RpcServiceMethod registration."""
+        service_key = self._cache_key(service)
+        method_key = self._cache_key(method)
+        interface_type = self.service_interface_type_path(service)
+        method_name = 
self._rpc_method_identifier_cache[service_key][method_key]
+        path_constant = self.service_path_constant_type_path(service, method)
+        request_type = self.service_type_path(method.request_type)
+        response_type = self.service_type_path(method.response_type)
+        method_type = self._grpc_method_type(method)
+        mode = streaming_mode(method)
+        lines = [
+            "AddMethod(new ::grpc::internal::RpcServiceMethod(",
+            f"    {path_constant}, 
::grpc::internal::RpcMethod::{method_type},",
+        ]
+        if mode == StreamingMode.UNARY:
+            lines.extend(
+                [
+                    "    new ::grpc::internal::RpcMethodHandler<",
+                    f"        {interface_type}, {request_type}, 
{response_type}>(",
+                    f"        []({interface_type}* service, 
::grpc::ServerContext* context,",
+                    f"           const {request_type}* request, 
{response_type}* response) {{",
+                    f"          return service->{method_name}(context, 
request, response);",
+                    "        },",
+                ]
+            )
+        elif mode == StreamingMode.CLIENT_STREAMING:
+            lines.extend(
+                [
+                    "    new ::grpc::internal::ClientStreamingHandler<",
+                    f"        {interface_type}, {request_type}, 
{response_type}>(",
+                    f"        []({interface_type}* service, 
::grpc::ServerContext* context,",
+                    f"           ::grpc::ServerReader<{request_type}>* 
reader,",
+                    f"           {response_type}* response) {{",
+                    f"          return service->{method_name}(context, reader, 
response);",
+                    "        },",
+                ]
+            )
+        elif mode == StreamingMode.SERVER_STREAMING:
+            lines.extend(
+                [
+                    "    new ::grpc::internal::ServerStreamingHandler<",
+                    f"        {interface_type}, {request_type}, 
{response_type}>(",
+                    f"        []({interface_type}* service, 
::grpc::ServerContext* context,",
+                    f"           const {request_type}* request,",
+                    f"           ::grpc::ServerWriter<{response_type}>* 
writer) {{",
+                    f"          return service->{method_name}(context, 
request, writer);",
+                    "        },",
+                ]
+            )
+        else:
+            lines.extend(
+                [
+                    "    new ::grpc::internal::BidiStreamingHandler<",
+                    f"        {interface_type}, {request_type}, 
{response_type}>(",
+                    f"        []({interface_type}* service, 
::grpc::ServerContext* context,",
+                    "           ::grpc::ServerReaderWriter<",
+                    f"               {response_type}, {request_type}>* stream) 
{{",
+                    f"          return service->{method_name}(context, 
stream);",
+                    "        },",
+                ]
+            )
+        lines.extend(["        impl_)));", ""])
+        return lines
+
+    def _grpc_method_type(self, method: RpcMethod) -> str:
+        mode = streaming_mode(method)
+        return {
+            StreamingMode.UNARY: "NORMAL_RPC",
+            StreamingMode.CLIENT_STREAMING: "CLIENT_STREAMING",
+            StreamingMode.SERVER_STREAMING: "SERVER_STREAMING",
+            StreamingMode.BIDIRECTIONAL: "BIDI_STREAMING",
+        }[mode]
+
+    def service_namespace(self) -> str:
+        schema_namespace = self.get_namespace()
+        if schema_namespace:
+            return f"{schema_namespace}::service"
+        return "service"
+
+    def service_interface_type_path(self, service: Service) -> str:
+        service_key = self._cache_key(service)
+        interface_name = self._service_interface_identifier_cache[service_key]
+        return f"::{self.service_namespace()}::{interface_name}"
+
+    def service_path_constant_type_path(
+        self, service: Service, method: RpcMethod
+    ) -> str:
+        service_key = self._cache_key(service)
+        method_key = self._cache_key(method)
+        constant = 
self._rpc_path_constant_identifier_cache[service_key][method_key]
+        return f"::{self.service_namespace()}::{constant}"
diff --git a/compiler/fory_compiler/generators/services/rust.py 
b/compiler/fory_compiler/generators/services/rust.py
index 16cf5954e..0edba4a30 100644
--- a/compiler/fory_compiler/generators/services/rust.py
+++ b/compiler/fory_compiler/generators/services/rust.py
@@ -20,6 +20,7 @@
 from typing import Dict, List, Optional, Set, Tuple
 
 from fory_compiler.generators.base import GeneratedFile
+from fory_compiler.generators.services.base import StreamingMode, 
streaming_mode
 from fory_compiler.ir.ast import (
     ArrayType,
     Field,
@@ -57,6 +58,28 @@ class RustServiceGeneratorMixin:
     def allocate_grpc_service_identifiers(self, services: List[Service]) -> 
None:
         """Allocate sanitized identifiers used by generated gRPC code."""
         self._ensure_name_caches(self.schema)
+        if not hasattr(self, "_named_service_schema_ids"):
+            self._named_service_schema_ids: Set[int] = set()
+            self._service_trait_identifier_cache: Dict[Tuple[object, ...], 
str] = {}
+            self._service_client_module_identifier_cache: Dict[
+                Tuple[object, ...], str
+            ] = {}
+            self._service_server_module_identifier_cache: Dict[
+                Tuple[object, ...], str
+            ] = {}
+            self._service_name_constant_identifier_cache: Dict[
+                Tuple[object, ...], str
+            ] = {}
+            self._rpc_method_identifier_cache: Dict[
+                Tuple[object, ...], Dict[Tuple[object, ...], str]
+            ] = {}
+            self._rpc_stream_type_identifier_cache: Dict[
+                Tuple[object, ...], Dict[Tuple[object, ...], str]
+            ] = {}
+            self._rpc_path_constant_identifier_cache: Dict[
+                Tuple[object, ...], Dict[Tuple[object, ...], str]
+            ] = {}
+
         schema_id = id(self.schema)
         if schema_id in self._named_service_schema_ids:
             return
@@ -265,12 +288,13 @@ class RustServiceGeneratorMixin:
         method_name = 
self._rpc_method_identifier_cache[service_key][method_key]
         request_type = self.service_type_path(method.request_type)
         response_type = self.service_type_path(method.response_type)
+        mode = streaming_mode(method)
         lines: List[str] = []
-        if method.client_streaming:
+        if mode in (StreamingMode.CLIENT_STREAMING, 
StreamingMode.BIDIRECTIONAL):
             request_arg_type = 
f"::tonic::Request<::tonic::Streaming<{request_type}>>"
         else:
             request_arg_type = f"::tonic::Request<{request_type}>"
-        if method.server_streaming:
+        if mode in (StreamingMode.SERVER_STREAMING, 
StreamingMode.BIDIRECTIONAL):
             stream_type = self._rpc_stream_type_identifier_cache[service_key][
                 method_key
             ]
diff --git a/compiler/fory_compiler/tests/test_service_codegen.py 
b/compiler/fory_compiler/tests/test_service_codegen.py
index 344a1eb98..e2798aa5b 100644
--- a/compiler/fory_compiler/tests/test_service_codegen.py
+++ b/compiler/fory_compiler/tests/test_service_codegen.py
@@ -18,6 +18,7 @@
 """Codegen smoke tests for schemas that contain service definitions."""
 
 from pathlib import Path
+import re
 import shutil
 import subprocess
 from textwrap import dedent
@@ -158,6 +159,7 @@ def test_unsupported_generators_no_services():
             KotlinGenerator,
             JavaScriptGenerator,
             DartGenerator,
+            CppGenerator,
         ):
             continue
         options = GeneratorOptions(output_dir=Path("/tmp"))
@@ -1037,6 +1039,32 @@ def test_grpc_streaming_method_shapes():
     assert "grpc.ClientStream" in go
     assert "grpc.ServerStream" in go
 
+    rust = next(iter(generate_service_files(schema, RustGenerator).values()))
+    assert (
+        "async fn unary(\n"
+        "        &self,\n"
+        "        request: ::tonic::Request<crate::demo_streams::Req>," in rust
+    )
+    assert (
+        "async fn server(\n"
+        "        &self,\n"
+        "        request: ::tonic::Request<crate::demo_streams::Req>," in rust
+    )
+    assert "::tonic::Response<Self::ServerStream>" in rust
+    assert (
+        "async fn client(\n"
+        "        &self,\n"
+        "        request: ::tonic::Request<"
+        "::tonic::Streaming<crate::demo_streams::Req>>," in rust
+    )
+    assert (
+        "async fn bidi(\n"
+        "        &self,\n"
+        "        request: ::tonic::Request<"
+        "::tonic::Streaming<crate::demo_streams::Payload>>," in rust
+    )
+    assert "::tonic::Response<Self::BidiStream>" in rust
+
     kotlin = next(iter(generate_service_files(schema, 
KotlinGenerator).values()))
     assert "io.grpc.MethodDescriptor.MethodType.UNARY" in kotlin
     assert "io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING" in kotlin
@@ -1982,6 +2010,9 @@ def test_grpc_flag_compiles_services(tmp_path: Path, 
capsys):
     assert output.count("demo_greeter_grpc.go") == 1
     assert (lang_dirs["rust"] / "demo_greeter_service.rs").exists()
     assert (lang_dirs["rust"] / "demo_greeter_service_grpc.rs").exists()
+    assert (lang_dirs["cpp"] / "demo_greeter.service.h").exists()
+    assert (lang_dirs["cpp"] / "demo_greeter.service.grpc.h").exists()
+    assert (lang_dirs["cpp"] / "demo_greeter.service.grpc.cc").exists()
     assert (lang_dirs["csharp"] / "demo" / "greeter" / "Service.cs").exists()
     assert (lang_dirs["csharp"] / "demo" / "greeter" / 
"GreeterGrpc.cs").exists()
     assert (lang_dirs["scala"] / "demo" / "greeter" / 
"GreeterGrpc.scala").exists()
@@ -3511,3 +3542,427 @@ def test_dart_grpc_reserved_methods():
         msg = str(excinfo.value)
         assert "inherited Dart member" in msg
         assert f"Svc.{rpc_name} -> {emitted}" in msg
+
+
+def test_cpp_grpc_companions_and_codec():
+    schema = parse_fdl(_GREETER_WITH_SERVICE)
+    files = generate_service_files(schema, CppGenerator)
+    assert set(files) == {
+        "demo_greeter.service.h",
+        "demo_greeter.service.grpc.h",
+        "demo_greeter.service.grpc.cc",
+    }
+
+    api = files["demo_greeter.service.h"]
+    assert "namespace demo::greeter::service {" in api
+    assert "class Greeter {" in api
+    assert "virtual ::grpc::Status SayHello(" in api
+    assert 'GreeterServiceName[] = "demo.greeter.Greeter"' in api
+    assert 'GreeterSayHelloPath[] = "/demo.greeter.Greeter/SayHello"' in api
+
+    header = files["demo_greeter.service.grpc.h"]
+    assert '#include "demo_greeter.service.h"' in header
+    assert "FORY_GENERATED_GRPC_SERIALIZATION_TRAITS_" in header
+    assert "class ForyGrpcSerializationTraits" in header
+    assert "SerializationTraits<::demo::greeter::HelloRequest, void>" in header
+    assert "SerializationTraits<::demo::greeter::HelloReply, void>" in header
+    assert "template <class Message, auto GetFory>" in header
+    assert "GetFory().serialize_to(*bytes, message)" in header
+    assert "new ::std::vector<::uint8_t>()" in header
+    assert "message.to_bytes()" not in header
+    assert "&::demo::greeter::detail::get_fory" in header
+    assert "Message::from_bytes(slice.begin(), slice.size())" in header
+    assert "namespace demo::greeter::service::grpc {" in header
+    assert "class GreeterStub final" in header
+    assert "class GreeterServiceGrpc final : public ::grpc::Service" in header
+    assert (
+        "explicit GreeterServiceGrpc(::demo::greeter::service::Greeter* impl);"
+        in header
+    )
+    assert "The caller owns impl; it must outlive this adapter and server." in 
header
+
+    source = files["demo_greeter.service.grpc.cc"]
+    assert '#include "demo_greeter.service.grpc.h"' in source
+    assert "namespace demo::greeter::service::grpc {" in source
+    assert "::demo::greeter::service::GreeterSayHelloPath" in source
+    assert "BlockingUnaryCall<" in source
+    assert "RpcMethod::NORMAL_RPC" in source
+    assert "RpcMethodHandler<" in source
+
+
+def test_cpp_grpc_streaming_modes():
+    schema = parse_fdl(
+        dedent(
+            """
+            package demo.streaming;
+
+            message Req {}
+            message Res {}
+
+            service Streamer {
+                rpc Unary (Req) returns (Res);
+                rpc Upload (stream Req) returns (Res);
+                rpc Download (Req) returns (stream Res);
+                rpc Chat (stream Req) returns (stream Res);
+            }
+            """
+        )
+    )
+    files = generate_service_files(schema, CppGenerator)
+    api = files["demo_streaming.service.h"]
+    header = files["demo_streaming.service.grpc.h"]
+    source = files["demo_streaming.service.grpc.cc"]
+
+    assert "::grpc::ServerReader<::demo::streaming::Req>* reader" in api
+    assert "::grpc::ServerWriter<::demo::streaming::Res>* writer" in api
+    assert "::grpc::ServerReaderWriter<" in api
+    assert "::demo::streaming::Res, ::demo::streaming::Req>* stream" in api
+
+    assert "::grpc::ClientWriter<::demo::streaming::Req>" in header
+    assert "::grpc::ClientReader<::demo::streaming::Res>" in header
+    assert "::grpc::ClientReaderWriter<" in header
+    assert "::demo::streaming::Req, ::demo::streaming::Res" in header
+
+    assert "RpcMethod::NORMAL_RPC" in source
+    assert "RpcMethod::CLIENT_STREAMING" in source
+    assert "RpcMethod::SERVER_STREAMING" in source
+    assert "RpcMethod::BIDI_STREAMING" in source
+    assert "ClientWriterFactory<::demo::streaming::Req>::Create" in source
+    assert "ClientReaderFactory<::demo::streaming::Res>::Create" in source
+    assert "ClientReaderWriterFactory<" in source
+    assert "ClientStreamingHandler<" in source
+    assert "ServerStreamingHandler<" in source
+    assert "BidiStreamingHandler<" in source
+
+
+def test_cpp_grpc_nested_union_and_default_package():
+    schema = parse_fdl(
+        dedent(
+            """
+            message Envelope {
+                message Request {}
+                union Reply {
+                    string text = 1;
+                }
+            }
+
+            service Nested {
+                rpc Call (Envelope.Request) returns (Envelope.Reply);
+            }
+            """
+        )
+    )
+    files = generate_service_files(schema, CppGenerator)
+    assert set(files) == {
+        "generated.service.h",
+        "generated.service.grpc.h",
+        "generated.service.grpc.cc",
+    }
+    api = files["generated.service.h"]
+    header = files["generated.service.grpc.h"]
+    assert "namespace service {" in api
+    assert "namespace service::grpc {" in header
+    assert 'NestedServiceName[] = "Nested"' in api
+    assert 'NestedCallPath[] = "/Nested/Call"' in api
+    assert "const ::Envelope::Request* request" in api
+    assert "::Envelope::Reply* response" in api
+    assert "SerializationTraits<::Envelope::Request, void>" in header
+    assert "SerializationTraits<::Envelope::Reply, void>" in header
+    assert "&::detail::get_fory" in header
+
+
+def test_cpp_grpc_imported_message_paths(tmp_path: Path):
+    common = tmp_path / "common.fdl"
+    common.write_text(
+        dedent(
+            """
+            package demo.common;
+
+            message Envelope {
+                message Request {}
+                union Reply {
+                    string text = 1;
+                }
+            }
+            """
+        )
+    )
+    service = tmp_path / "service.fdl"
+    service.write_text(
+        dedent(
+            """
+            package demo.api;
+            import "common.fdl";
+
+            service Api {
+                rpc Call (demo.common.Envelope.Request)
+                    returns (demo.common.Envelope.Reply);
+            }
+            """
+        )
+    )
+    schema = resolve_imports(service)
+    files = generate_service_files(schema, CppGenerator)
+    assert set(files) == {
+        "demo_api.service.h",
+        "demo_api.service.grpc.h",
+        "demo_api.service.grpc.cc",
+    }
+    api = files["demo_api.service.h"]
+    header = files["demo_api.service.grpc.h"]
+    assert "const ::demo::common::Envelope::Request* request" in api
+    assert "::demo::common::Envelope::Reply* response" in api
+    assert "SerializationTraits<::demo::common::Envelope::Request, void>" in 
header
+    assert "SerializationTraits<::demo::common::Envelope::Reply, void>" in 
header
+    assert "&::demo::common::detail::get_fory" in header
+
+
+def test_cpp_grpc_shared_message_specialization_guard(tmp_path: Path):
+    common = tmp_path / "common.fdl"
+    common.write_text(
+        dedent(
+            """
+            package demo.common;
+            message Shared {}
+            """
+        )
+    )
+    headers = []
+    for name in ("first", "second"):
+        service = tmp_path / f"{name}.fdl"
+        service.write_text(
+            dedent(
+                f"""
+                package demo.{name};
+                import "common.fdl";
+                service Api {{
+                    rpc Call (demo.common.Shared) returns (demo.common.Shared);
+                }}
+                """
+            )
+        )
+        schema = resolve_imports(service)
+        files = generate_service_files(schema, CppGenerator)
+        headers.append(files[f"demo_{name}.service.grpc.h"])
+
+    guard_pattern = re.compile(
+        r"FORY_GENERATED_GRPC_TRAITS_DEMO_COMMON_SHARED_[0-9A-F]{12}_"
+    )
+    first_guard = guard_pattern.search(headers[0])
+    second_guard = guard_pattern.search(headers[1])
+    assert first_guard is not None
+    assert second_guard is not None
+    assert first_guard.group(0) == second_guard.group(0)
+    assert headers[0].count("SerializationTraits<::demo::common::Shared, 
void>") == 1
+    assert headers[1].count("SerializationTraits<::demo::common::Shared, 
void>") == 1
+
+
+def test_cpp_grpc_name_collisions():
+    schema = parse_fdl(
+        dedent(
+            """
+            package demo.collision;
+            message Greeter {}
+            message Req {}
+            message Res {}
+            service Greeter {
+                rpc Call (Req) returns (Res);
+            }
+            """
+        )
+    )
+    files = generate_service_files(schema, CppGenerator)
+    assert "namespace demo::collision::service {" in 
files["demo_collision.service.h"]
+    assert "class Greeter {" in files["demo_collision.service.h"]
+
+    service_schema = parse_fdl(
+        dedent(
+            """
+            package demo.collision;
+            message Req {}
+            message Res {}
+            service Greeter {
+                rpc Call (Req) returns (Res);
+            }
+            service GreeterServiceName {
+                rpc Call (Req) returns (Res);
+            }
+            """
+        )
+    )
+    with pytest.raises(ValueError, match="C\\+\\+ name collision"):
+        generate_service_files(service_schema, CppGenerator)
+
+    grpc_namespace_schema = parse_fdl(
+        dedent(
+            """
+            package demo.collision;
+            message Req {}
+            message Res {}
+            service grpc {
+                rpc Call (Req) returns (Res);
+            }
+            """
+        )
+    )
+    with pytest.raises(ValueError, match="generated gRPC transport namespace"):
+        generate_service_files(grpc_namespace_schema, CppGenerator)
+
+    method_schema = parse_fdl(
+        dedent(
+            """
+            package demo.collision;
+            message Req {}
+            message Res {}
+            service Greeter {
+                rpc NewStub (Req) returns (Res);
+            }
+            """
+        )
+    )
+    method_files = generate_service_files(method_schema, CppGenerator)
+    method_header = method_files["demo_collision.service.grpc.h"]
+    method_source = method_files["demo_collision.service.grpc.cc"]
+    assert "  static ::std::unique_ptr<GreeterStub> NewStub(" in method_header
+    assert (
+        "  ::grpc::Status NewStub(\n      ::grpc::ClientContext* context,"
+        in method_header
+    )
+    assert (
+        "::grpc::Status GreeterStub::NewStub(\n    ::grpc::ClientContext* 
context,"
+        in method_source
+    )
+
+    constructor_schema = parse_fdl(
+        dedent(
+            """
+            package demo.collision;
+            message Req {}
+            message Res {}
+            service Greeter {
+                rpc Greeter (Req) returns (Res);
+                rpc GreeterStub (Req) returns (Res);
+            }
+            """
+        )
+    )
+    constructor_files = generate_service_files(constructor_schema, 
CppGenerator)
+    constructor_api = constructor_files["demo_collision.service.h"]
+    constructor_header = constructor_files["demo_collision.service.grpc.h"]
+    constructor_source = constructor_files["demo_collision.service.grpc.cc"]
+    assert "virtual ::grpc::Status Greeter_(" in constructor_api
+    assert "::grpc::Status GreeterStub_(" in constructor_header
+    assert "::grpc::Status GreeterStub::Greeter_(" in constructor_source
+    assert "::grpc::Status GreeterStub::GreeterStub_(" in constructor_source
+    assert 'GreeterGreeterPath[] = "/demo.collision.Greeter/Greeter"' in 
constructor_api
+    assert (
+        'GreeterGreeterStubPath[] = "/demo.collision.Greeter/GreeterStub"'
+        in constructor_api
+    )
+
+    reserved_name_collision_schema = parse_fdl(
+        dedent(
+            """
+            package demo.collision;
+            message Req {}
+            message Res {}
+            service Greeter {
+                rpc Greeter (Req) returns (Res);
+                rpc Greeter_ (Req) returns (Res);
+            }
+            """
+        )
+    )
+    with pytest.raises(ValueError, match="C\\+\\+ name collision"):
+        generate_service_files(reserved_name_collision_schema, CppGenerator)
+
+    channel_member_schema = parse_fdl(
+        dedent(
+            """
+            package demo.collision;
+            message Req {}
+            message Res {}
+            service Greeter {
+                rpc channel_ (Req) returns (Res);
+            }
+            """
+        )
+    )
+    with pytest.raises(ValueError, match="conflicts with member 'channel_'"):
+        generate_service_files(channel_member_schema, CppGenerator)
+
+
[email protected](
+    "source",
+    [
+        """
+        message grpc {}
+        message Req {}
+        message Res {}
+        service Api {
+            rpc Call (Req) returns (Res);
+        }
+        """,
+        """
+        package grpc;
+        message Req {}
+        message Res {}
+        service Api {
+            rpc Call (Req) returns (Res);
+        }
+        """,
+    ],
+    ids=("type", "package"),
+)
+def test_cpp_grpc_root_namespace_collision(source: str):
+    with pytest.raises(ValueError, match="gRPC root namespace"):
+        generate_service_files(parse_fdl(dedent(source)), CppGenerator)
+
+
+def test_cpp_grpc_recursive_output_paths(tmp_path: Path):
+    service_model = tmp_path / "service_model.fdl"
+    service_model.write_text(
+        dedent(
+            """
+            package demo_service;
+            message ServiceModel {}
+            """
+        )
+    )
+    grpc_model = tmp_path / "grpc_model.fdl"
+    grpc_model.write_text(
+        dedent(
+            """
+            package demo_service_grpc;
+            message GrpcModel {}
+            """
+        )
+    )
+    root = tmp_path / "root.fdl"
+    root.write_text(
+        dedent(
+            """
+            package demo;
+            import "service_model.fdl";
+            import "grpc_model.fdl";
+
+            message Req {}
+            message Res {}
+            service Api {
+                rpc Call (Req) returns (Res);
+            }
+            """
+        )
+    )
+    cpp_out = tmp_path / "cpp"
+    args = parse_args([str(root), "--cpp_out", str(cpp_out), "--grpc"])
+
+    assert cmd_compile(args) == 0
+    assert {path.name for path in cpp_out.iterdir()} == {
+        "demo.h",
+        "demo.service.h",
+        "demo.service.grpc.h",
+        "demo.service.grpc.cc",
+        "demo_service.h",
+        "demo_service_grpc.h",
+    }
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index 06537e000..a6330d8dc 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -122,6 +122,7 @@ add_subdirectory(fory/encoder)
 # Create main fory_serialization interface library (for users who only need 
serialization)
 add_library(fory_serialization_lib INTERFACE)
 target_link_libraries(fory_serialization_lib INTERFACE fory_serialization)
+set_target_properties(fory_serialization_lib PROPERTIES EXPORT_NAME 
serialization)
 add_library(fory::serialization ALIAS fory_serialization_lib)
 
 # Create main fory_row_format interface library (for users who need row format)
diff --git a/docs/compiler/compiler-guide.md b/docs/compiler/compiler-guide.md
index 323e9a19d..abe4721f8 100644
--- a/docs/compiler/compiler-guide.md
+++ b/docs/compiler/compiler-guide.md
@@ -149,15 +149,18 @@ foryc user.fdl order.fdl product.fdl --output ./generated
 foryc compiler/examples/service.fdl --java_out=./generated/java 
--python_out=./generated/python --go_out=./generated/go 
--rust_out=./generated/rust --csharp_out=./generated/csharp 
--dart_out=./generated/dart --scala_out=./generated/scala 
--kotlin_out=./generated/kotlin --javascript_out=./generated/javascript
 ```
 
-**Generate Java, Python, Go, Rust, C#, Dart, Scala, Kotlin, and Node.js 
JavaScript gRPC service companions:**
+**Generate Java, Python, Go, Rust, C++, C#, Dart, Scala, Kotlin, and Node.js 
JavaScript gRPC service companions:**
 
 ```bash
-foryc compiler/examples/service.fdl --java_out=./generated/java 
--python_out=./generated/python --go_out=./generated/go 
--rust_out=./generated/rust --csharp_out=./generated/csharp 
--dart_out=./generated/dart --scala_out=./generated/scala 
--kotlin_out=./generated/kotlin --javascript_out=./generated/javascript --grpc
+foryc compiler/examples/service.fdl --java_out=./generated/java 
--python_out=./generated/python --go_out=./generated/go 
--rust_out=./generated/rust --cpp_out=./generated/cpp 
--csharp_out=./generated/csharp --dart_out=./generated/dart 
--scala_out=./generated/scala --kotlin_out=./generated/kotlin 
--javascript_out=./generated/javascript --grpc
 ```
 
 The generated gRPC service code uses Fory to serialize request and response
 payloads. Java output imports grpc-java APIs, Python output defaults to
 `grpc.aio`, Go output imports grpc-go, Rust output imports `tonic` and `bytes`,
+C++ output includes gRPC C++ `grpcpp` headers; targets compiling it must add 
the
+generated output directory to their include path and link `fory::serialization`
+and `gRPC::grpc++`.
 Scala output imports grpc-java APIs, and Kotlin output imports grpc-java and
 grpc-kotlin APIs and uses coroutine stubs. C# output imports `Grpc.Core.Api`
 types and can be hosted with normal .NET gRPC packages such as 
`Grpc.AspNetCore`
diff --git a/docs/compiler/generated-code.md b/docs/compiler/generated-code.md
index 7c8d79cf2..6e1936945 100644
--- a/docs/compiler/generated-code.md
+++ b/docs/compiler/generated-code.md
@@ -610,6 +610,8 @@ class Person final {
     void set_number(Arg&& arg, Args&&... args);
 
     fory::Result<std::vector<uint8_t>, fory::Error> to_bytes() const;
+    static fory::Result<PhoneNumber, fory::Error> from_bytes(
+        const uint8_t* data, std::size_t size);
     static fory::Result<PhoneNumber, fory::Error> from_bytes(const 
std::vector<uint8_t>& data);
   };
 
@@ -721,6 +723,54 @@ auto bytes = person.to_bytes();
 auto restored = addressbook::Person::from_bytes(bytes.value());
 ```
 
+### gRPC Service Companions
+
+When a schema contains services and the compiler is run with `--grpc`, C++
+generation emits a service API header file and gRPC binding files. For a schema
+header named `addressbook.h`, those files are `addressbook.service.h`,
+`addressbook.service.grpc.h`, and `addressbook.service.grpc.cc`.
+
+The service API header file contains synchronous business interfaces and gRPC 
path
+constants under `::<schema namespace>::service`:
+
+```cpp
+namespace addressbook::service {
+
+class AddressBookService {
+ public:
+  virtual ~AddressBookService() = default;
+
+  virtual ::grpc::Status Lookup(
+      ::grpc::ServerContext* context,
+      const ::addressbook::Person* request,
+      ::addressbook::AddressBook* response) = 0;
+};
+
+inline constexpr char AddressBookServiceServiceName[] =
+    "addressbook.AddressBookService";
+inline constexpr char AddressBookServiceLookupPath[] =
+    "/addressbook.AddressBookService/Lookup";
+
+}  // namespace addressbook::service
+```
+
+The gRPC binding header file and source file contain Fory-backed codecs, 
generated
+`grpc::SerializationTraits` specializations, and synchronous client/server
+wrappers under `::<schema namespace>::service::grpc`. They serialize each
+request or response with the generated model type's `to_bytes` and `from_bytes`
+helpers:
+
+```cpp
+template <>
+class SerializationTraits<::addressbook::Person, void>
+    : public ::fory::grpc::detail::ForyGrpcSerializationTraits<
+          ::addressbook::Person> {};
+```
+
+Applications compiling the generated C++ service files must provide gRPC C++
+1.39.0 or later and link the generated `.service.grpc.cc` file with Fory
+serialization.
+
 ## Go
 
 ### Output Layout
diff --git a/docs/compiler/index.md b/docs/compiler/index.md
index caa69a6fc..4d89c4634 100644
--- a/docs/compiler/index.md
+++ b/docs/compiler/index.md
@@ -23,9 +23,9 @@ Fory IDL is a schema definition language for Apache Fory that 
enables type-safe
 cross-language serialization. Define your data structures once and generate
 native data structure code for Java, Python, C++, Go, Rust,
 JavaScript/TypeScript, C#, Swift, Dart, Scala, and Kotlin. Fory IDL can also
-describe RPC services; for Java, Python, Go, Rust, C#, Dart, Scala, Kotlin, and
-JavaScript, the compiler can generate gRPC service companions that use Fory
-serialization for request and response payloads.
+describe RPC services; for Java, Python, Go, Rust, C++, C#, Dart, Scala, 
Kotlin,
+and JavaScript, the compiler can generate gRPC service companions that use
+Fory serialization for request and response payloads.
 
 ## Example Schema
 
@@ -88,21 +88,23 @@ service AnimalService {
 }
 ```
 
-Generate Java, Python, Go, Rust, C#, Dart, Scala, Kotlin, and JavaScript models
-plus gRPC service companions with:
+Generate Java, Python, Go, Rust, C++, C#, Dart, Scala, Kotlin, and JavaScript
+models plus gRPC service companions with:
 
 ```bash
-foryc animals.fdl --java_out=./generated/java --python_out=./generated/python 
--go_out=./generated/go --rust_out=./generated/rust 
--csharp_out=./generated/csharp --dart_out=./generated/dart 
--scala_out=./generated/scala --kotlin_out=./generated/kotlin 
--javascript_out=./generated/javascript --grpc
+foryc animals.fdl --java_out=./generated/java --python_out=./generated/python 
--go_out=./generated/go --rust_out=./generated/rust --cpp_out=./generated/cpp 
--csharp_out=./generated/csharp --dart_out=./generated/dart 
--scala_out=./generated/scala --kotlin_out=./generated/kotlin 
--javascript_out=./generated/javascript --grpc
 ```
 
 The generated service code uses normal gRPC APIs, but request and response
 objects are serialized with Fory. Applications provide their own grpc-java,
 grpc-kotlin, Scala grpc-java APIs, `grpcio`, grpc-go, Rust `tonic` and `bytes`,
-C# `Grpc.Core.Api` and hosting/client dependencies, or Dart `package:grpc`; 
Fory
-packages do not add gRPC as a hard dependency. Python companions use `grpc.aio`
-by default and can be generated in sync mode with `--grpc-python-mode=sync`.
-JavaScript Node.js companions use `@grpc/grpc-js`; browser clients are 
generated
-separately with `--grpc-web` and use `grpc-web`.
+gRPC C++ 1.39.0 or later, C# `Grpc.Core.Api` and hosting/client dependencies, 
or
+Dart `package:grpc`; Fory packages do not add gRPC as a hard dependency. See
+[C++ gRPC Support](../guide/cpp/grpc-support.md) for C++ linking instructions.
+Python companions use `grpc.aio` by default and can be generated in sync mode
+with `--grpc-python-mode=sync`. JavaScript Node.js companions use
+`@grpc/grpc-js`; browser clients are generated separately with `--grpc-web` and
+use `grpc-web`.
 
 ## Why Fory IDL?
 
@@ -176,7 +178,7 @@ message Person {
 foryc example.fdl --output ./generated
 
 # Generate for specific languages
-foryc example.fdl --lang java,python,csharp,javascript,swift,dart,scala,kotlin 
--output ./generated
+foryc example.fdl --lang 
java,python,cpp,csharp,javascript,swift,dart,scala,kotlin --output ./generated
 ```
 
 ### 4. Use Generated Code
diff --git a/docs/guide/cpp/grpc-support.md b/docs/guide/cpp/grpc-support.md
new file mode 100644
index 000000000..4fe547d32
--- /dev/null
+++ b/docs/guide/cpp/grpc-support.md
@@ -0,0 +1,277 @@
+---
+title: gRPC Support
+sidebar_position: 12
+id: grpc_support
+license: |
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+---
+
+Fory can generate C++ gRPC service companions for schemas that define services.
+The generated code uses gRPC C++ for transport and Fory for request and
+response payload serialization. It requires gRPC C++ 1.39.0 or later.
+
+Use this mode when every RPC peer is generated from the same Fory IDL, protobuf
+IDL, or FlatBuffers IDL and you want gRPC transport semantics with Fory payload
+encoding. Use standard protobuf gRPC code generation when clients or tools must
+consume protobuf message bytes directly.
+
+## Add Dependencies
+
+With Bazel, use the Fory label that is visible from your workspace.
+The example below is for a project that consumes Fory as an external module 
named `fory`:
+
+```bazel
+load("@rules_cc//cc:defs.bzl", "cc_library")
+
+cc_library(
+    name = "greeter_generated",
+    srcs = ["generated/demo_greeter.service.grpc.cc"],
+    hdrs = glob(["generated/*.h"]),
+    includes = ["generated"],
+    deps = [
+        "@fory//cpp/fory/serialization:fory_serialization",
+        "@grpc//:grpc++",
+    ],
+)
+```
+
+Inside the Fory repository, use `//cpp/fory/serialization:fory_serialization`
+instead of `@fory//cpp/fory/serialization:fory_serialization`.
+
+With CMake, make the Fory C++ target visible first. For an installed Fory
+package, use `find_package(Fory CONFIG REQUIRED)`, then add the generated 
source
+and link both libraries explicitly:
+
+```cmake
+find_package(Fory CONFIG REQUIRED)
+find_package(gRPC 1.39.0 CONFIG REQUIRED)
+
+add_library(greeter_generated
+    generated/demo_greeter.service.grpc.cc
+)
+target_compile_features(greeter_generated PUBLIC cxx_std_17)
+target_include_directories(greeter_generated PUBLIC generated)
+target_link_libraries(greeter_generated PUBLIC
+    fory::serialization
+    gRPC::grpc++
+)
+```
+
+If your project brings Fory in with `FetchContent` or `add_subdirectory`, call
+that before linking `fory::serialization`.
+
+Use dependency versions that are compatible with the rest of your service
+stack.
+
+## Define a Service
+
+Service definitions can come from Fory IDL, protobuf IDL, or FlatBuffers
+`rpc_service` definitions. A Fory IDL service looks like this:
+
+```protobuf
+package demo.greeter;
+
+message HelloRequest {
+  string name = 1;
+}
+
+message HelloReply {
+  string reply = 1;
+}
+
+service Greeter {
+  rpc SayHello (HelloRequest) returns (HelloReply);
+}
+```
+
+Generate C++ model and gRPC companion code with `--grpc`:
+
+```bash
+foryc service.fdl --cpp_out=./generated/cpp --grpc
+```
+
+For this schema, the C++ generator emits:
+
+| File                           | Purpose                                     
       |
+| ------------------------------ | 
-------------------------------------------------- |
+| `demo_greeter.h`               | Fory model types and registration helpers   
       |
+| `demo_greeter.service.h`       | Synchronous service interface and path 
constants   |
+| `demo_greeter.service.grpc.h`  | Synchronous client, server adapter, and 
Fory codec |
+| `demo_greeter.service.grpc.cc` | Stub calls and server route implementations 
       |
+
+Include the generated gRPC header from application code and compile
+`demo_greeter.service.grpc.cc` once in your build target. The codec is 
generated
+directly in the gRPC header; there is no separate Fory gRPC runtime source 
file.
+
+## Implement a Server
+
+Implement the generated synchronous interface and register the generated server
+adapter with a normal gRPC C++ server.
+
+```cpp
+#include "demo_greeter.service.grpc.h"
+
+#include <memory>
+#include <grpcpp/server_builder.h>
+#include <grpcpp/security/server_credentials.h>
+
+class MyGreeter final : public demo::greeter::service::Greeter {
+ public:
+  ::grpc::Status SayHello(::grpc::ServerContext* context,
+                          const ::demo::greeter::HelloRequest* request,
+                          ::demo::greeter::HelloReply* response) override {
+    (void)context;
+    response->set_reply("Hello, " + request->name());
+    return ::grpc::Status::OK;
+  }
+};
+
+MyGreeter implementation;
+demo::greeter::service::grpc::GreeterServiceGrpc service(&implementation);
+::grpc::ServerBuilder builder;
+builder.AddListeningPort("0.0.0.0:50051", ::grpc::InsecureServerCredentials());
+builder.RegisterService(&service);
+std::unique_ptr<::grpc::Server> server = builder.BuildAndStart();
+server->Wait();
+```
+
+Generated request and response types are serialized by the generated service
+code, so service implementations do not perform manual Fory registration.
+
+## Create a Client
+
+Use the generated synchronous client stub:
+
+```cpp
+#include "demo_greeter.service.grpc.h"
+
+#include <iostream>
+#include <grpcpp/create_channel.h>
+#include <grpcpp/security/credentials.h>
+
+auto channel =
+    ::grpc::CreateChannel("localhost:50051", 
::grpc::InsecureChannelCredentials());
+auto stub = demo::greeter::service::grpc::GreeterStub::NewStub(channel);
+
+demo::greeter::HelloRequest request;
+request.set_name("Fory");
+demo::greeter::HelloReply response;
+::grpc::ClientContext context;
+::grpc::Status status = stub->SayHello(&context, request, &response);
+if (status.ok()) {
+  std::cout << response.reply() << std::endl;
+}
+```
+
+gRPC C++ still owns channel configuration, credentials, deadlines, metadata,
+cancellation, retry policy, and transport lifecycle.
+
+## Streaming RPCs
+
+Fory service definitions can use unary, server-streaming, client-streaming, and
+bidirectional streaming RPC shapes:
+
+```protobuf
+service Greeter {
+  rpc SayHello (HelloRequest) returns (HelloReply);
+  rpc LotsOfReplies (HelloRequest) returns (stream HelloReply);
+  rpc LotsOfGreetings (stream HelloRequest) returns (HelloReply);
+  rpc Chat (stream HelloRequest) returns (stream HelloReply);
+}
+```
+
+Generated C++ code follows synchronous gRPC C++ conventions:
+
+- Unary methods return `grpc::Status` and use request and response pointers.
+- Server-streaming methods return `std::unique_ptr<grpc::ClientReader<U>>` on
+  clients and receive `grpc::ServerWriter<U>*` on servers.
+- Client-streaming methods return `std::unique_ptr<grpc::ClientWriter<T>>` on
+  clients and receive `grpc::ServerReader<T>*` on servers.
+- Bidirectional methods return
+  `std::unique_ptr<grpc::ClientReaderWriter<T, U>>` on clients and receive
+  `grpc::ServerReaderWriter<U, T>*` on servers.
+- The generated codec is used for every message frame, including streaming
+  frames.
+
+Use the generated method signatures as the source of truth for concrete request
+and response types in your service implementation:
+
+```cpp
+::grpc::Status LotsOfReplies(
+    ::grpc::ServerContext* context,
+    const ::demo::greeter::HelloRequest* request,
+    ::grpc::ServerWriter<::demo::greeter::HelloReply>* writer) override {
+  (void)context;
+  ::demo::greeter::HelloReply reply;
+  reply.set_reply("Hello, " + request->name());
+  writer->Write(reply);
+  reply.set_reply("Welcome, " + request->name());
+  writer->Write(reply);
+  return ::grpc::Status::OK;
+}
+```
+
+Generated clients return standard gRPC C++ streaming helpers:
+
+```cpp
+demo::greeter::HelloRequest request;
+request.set_name("Fory");
+
+::grpc::ClientContext context;
+auto reader = stub->LotsOfReplies(&context, request);
+demo::greeter::HelloReply reply;
+while (reader->Read(&reply)) {
+  std::cout << reply.reply() << std::endl;
+}
+::grpc::Status status = reader->Finish();
+```
+
+Complete client streams with `WritesDone()` and always call `Finish()` to 
obtain
+the final status.
+
+The generated descriptors preserve the exact IDL service and method names for
+the gRPC path.
+
+## gRPC Runtime Behavior
+
+The generated service companion only supplies Fory serialization and gRPC C++
+bindings. Operational behavior remains standard gRPC C++ behavior:
+
+- Deadlines and cancellations
+- TLS and authentication
+- Status codes and metadata
+- Channel and server lifecycle
+- Synchronous streaming backpressure
+
+## Troubleshooting
+
+### Missing gRPC C++ Headers or Symbols
+
+Add the gRPC C++ dependency shown above to the target that compiles the
+generated service files, and compile the generated `.service.grpc.cc` file
+exactly once.
+
+### `UNIMPLEMENTED`
+
+Confirm that the generated server adapter was registered with
+`ServerBuilder::RegisterService(...)`, and that the client and server were
+generated from the same package, service, and method names.
+
+### Protobuf Clients Cannot Decode the Service
+
+Fory gRPC companions do not use protobuf wire encoding for messages. Use a
+Fory-generated client for Fory-generated services, or provide a separate
+protobuf service endpoint for generic protobuf clients.
diff --git a/docs/guide/cpp/index.md b/docs/guide/cpp/index.md
index d3a0f5c0e..b20df8a57 100644
--- a/docs/guide/cpp/index.md
+++ b/docs/guide/cpp/index.md
@@ -282,3 +282,4 @@ std::thread t2([&]() {
 - [Supported Types](supported-types.md) - All supported types
 - [Custom Serializers](custom-serializers.md) - Extend serialization behavior
 - [Row Format](row-format.md) - Zero-copy row-based format
+- [gRPC Support](grpc-support.md) - Fory payloads over gRPC C++
diff --git a/integration_tests/grpc_tests/cpp/CMakeLists.txt 
b/integration_tests/grpc_tests/cpp/CMakeLists.txt
new file mode 100644
index 000000000..d1c0af2b8
--- /dev/null
+++ b/integration_tests/grpc_tests/cpp/CMakeLists.txt
@@ -0,0 +1,56 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+cmake_minimum_required(VERSION 3.16)
+
+project(fory_grpc_tests LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+find_package(gRPC 1.39.0 CONFIG REQUIRED)
+
+include(FetchContent)
+
+FetchContent_Declare(
+    fory
+    SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../cpp"
+)
+
+FetchContent_MakeAvailable(fory)
+
+file(GLOB GENERATED_SERVICE_SOURCES CONFIGURE_DEPENDS
+    "${CMAKE_CURRENT_SOURCE_DIR}/generated/*.service.grpc.cc"
+)
+
+if(NOT GENERATED_SERVICE_SOURCES)
+    message(FATAL_ERROR "Generate the C++ gRPC test sources before configuring 
this project")
+endif()
+
+add_executable(grpc_interop
+    interop/main.cc
+    ${GENERATED_SERVICE_SOURCES}
+)
+
+target_include_directories(grpc_interop PRIVATE
+    "${CMAKE_CURRENT_SOURCE_DIR}/generated"
+)
+
+target_link_libraries(grpc_interop PRIVATE
+    fory::serialization
+    gRPC::grpc++
+)
diff --git a/integration_tests/grpc_tests/cpp/interop/main.cc 
b/integration_tests/grpc_tests/cpp/interop/main.cc
new file mode 100644
index 000000000..f306153be
--- /dev/null
+++ b/integration_tests/grpc_tests/cpp/interop/main.cc
@@ -0,0 +1,769 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "grpc_fbs.service.grpc.h"
+#include "grpc_fdl.service.grpc.h"
+#include "grpc_pb.service.grpc.h"
+
+#include <grpcpp/create_channel.h>
+#include <grpcpp/security/credentials.h>
+#include <grpcpp/server.h>
+#include <grpcpp/server_builder.h>
+
+#include <chrono>
+#include <cstdint>
+#include <exception>
+#include <fstream>
+#include <iostream>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace {
+
+void CheckStatus(const std::string &method, const ::grpc::Status &status) {
+  if (!status.ok()) {
+    throw std::runtime_error(method + ": " + status.error_message());
+  }
+}
+
+template <typename T>
+void CheckEqual(const std::string &method, const T &actual, const T &expected) 
{
+  if (!(actual == expected)) {
+    throw std::runtime_error(method + ": response mismatch");
+  }
+}
+
+template <typename T>
+void CheckEqual(const std::string &method, const std::vector<T> &actual,
+                const std::vector<T> &expected) {
+  if (actual != expected) {
+    throw std::runtime_error(method + ": response stream mismatch");
+  }
+}
+
+std::string Join(const std::vector<std::string> &values) {
+  std::string joined;
+  for (std::size_t index = 0; index < values.size(); ++index) {
+    if (index != 0) {
+      joined += "+";
+    }
+    joined += values[index];
+  }
+  return joined;
+}
+
+template <typename Request>
+Request MakeStringRequest(std::string id, std::int32_t count,
+                          std::string body) {
+  Request request;
+  request.set_id(std::move(id));
+  request.set_count(count);
+  request.set_payload(std::move(body));
+  return request;
+}
+
+template <typename Response, typename Request>
+Response MakeStringResponse(const Request &request, const std::string &tag,
+                            std::int32_t offset) {
+  Response response;
+  response.set_id(tag + ":" + request.id());
+  response.set_count(request.count() + offset);
+  response.set_payload(tag + ":" + request.payload());
+  return response;
+}
+
+template <typename Response, typename Request>
+Response AggregateStringRequests(const std::vector<Request> &requests) {
+  std::vector<std::string> ids;
+  std::vector<std::string> bodies;
+  std::int32_t count = 0;
+  for (const auto &request : requests) {
+    ids.push_back(request.id());
+    bodies.push_back(request.payload());
+    count += request.count();
+  }
+  Response response;
+  response.set_id("client:" + Join(ids));
+  response.set_count(count);
+  response.set_payload("client:" + Join(bodies));
+  return response;
+}
+
+grpc_pb::GrpcPbRequest MakePbRequest(std::string id, std::uint32_t count,
+                                     grpc_pb::GrpcPbRequest::Payload body) {
+  grpc_pb::GrpcPbRequest request;
+  request.set_id(std::move(id));
+  request.set_count(count);
+  *request.mutable_payload() = std::move(body);
+  return request;
+}
+
+grpc_pb::GrpcPbResponse MakePbResponse(const grpc_pb::GrpcPbRequest &request,
+                                       const std::string &tag,
+                                       std::uint32_t offset) {
+  grpc_pb::GrpcPbResponse response;
+  response.set_id(tag + ":" + request.id());
+  response.set_count(request.count() + offset);
+  if (request.has_payload()) {
+    if (request.payload().is_text()) {
+      *response.mutable_payload() = grpc_pb::GrpcPbResponse::Payload::text(
+          tag + ":" + request.payload().text());
+    } else {
+      *response.mutable_payload() = grpc_pb::GrpcPbResponse::Payload::number(
+          request.payload().number() + offset);
+    }
+  }
+  return response;
+}
+
+grpc_pb::GrpcPbResponse
+AggregatePbRequests(const std::vector<grpc_pb::GrpcPbRequest> &requests) {
+  std::vector<std::string> ids;
+  std::uint32_t count = 0;
+  for (const auto &request : requests) {
+    ids.push_back(request.id());
+    count += request.count();
+  }
+  grpc_pb::GrpcPbResponse response;
+  response.set_id("client:" + Join(ids));
+  response.set_count(count);
+  *response.mutable_payload() =
+      grpc_pb::GrpcPbResponse::Payload::text("client:" + Join(ids));
+  return response;
+}
+
+template <typename Stub, typename Request, typename Response,
+          typename ResponseFactory, typename AggregateFactory>
+void ExerciseMessages(Stub *stub, const std::vector<Request> &requests,
+                      ResponseFactory response_factory,
+                      AggregateFactory aggregate_factory) {
+  const Request &first = requests.front();
+
+  Response unary_response;
+  ::grpc::ClientContext unary_context;
+  CheckStatus("UnaryMessage",
+              stub->UnaryMessage(&unary_context, first, &unary_response));
+  CheckEqual("UnaryMessage", unary_response,
+             response_factory(first, "unary", 10));
+
+  std::vector<Response> server_responses;
+  ::grpc::ClientContext server_context;
+  auto reader = stub->ServerStreamMessage(&server_context, first);
+  Response server_response;
+  while (reader->Read(&server_response)) {
+    server_responses.push_back(server_response);
+  }
+  CheckStatus("ServerStreamMessage", reader->Finish());
+  CheckEqual("ServerStreamMessage", server_responses,
+             std::vector<Response>{response_factory(first, "server-0", 0),
+                                   response_factory(first, "server-1", 1),
+                                   response_factory(first, "server-2", 2)});
+
+  Response client_response;
+  ::grpc::ClientContext client_context;
+  auto writer = stub->ClientStreamMessage(&client_context, &client_response);
+  for (const auto &request : requests) {
+    if (!writer->Write(request)) {
+      throw std::runtime_error("ClientStreamMessage: write failed");
+    }
+  }
+  writer->WritesDone();
+  CheckStatus("ClientStreamMessage", writer->Finish());
+  CheckEqual("ClientStreamMessage", client_response,
+             aggregate_factory(requests));
+
+  std::vector<Response> bidi_responses;
+  ::grpc::ClientContext bidi_context;
+  auto stream = stub->BidiStreamMessage(&bidi_context);
+  // Read each echo before sending the next request so synchronous flow control
+  // cannot block both peers.
+  for (const auto &request : requests) {
+    if (!stream->Write(request)) {
+      throw std::runtime_error("BidiStreamMessage: write failed");
+    }
+    Response bidi_response;
+    if (!stream->Read(&bidi_response)) {
+      throw std::runtime_error("BidiStreamMessage: response read failed");
+    }
+    bidi_responses.push_back(bidi_response);
+  }
+  stream->WritesDone();
+  Response extra_bidi_response;
+  if (stream->Read(&extra_bidi_response)) {
+    throw std::runtime_error("BidiStreamMessage: unexpected response");
+  }
+  CheckStatus("BidiStreamMessage", stream->Finish());
+  std::vector<Response> expected_bidi;
+  for (std::size_t index = 0; index < requests.size(); ++index) {
+    expected_bidi.push_back(response_factory(
+        requests[index], "bidi-" + std::to_string(index), index));
+  }
+  CheckEqual("BidiStreamMessage", bidi_responses, expected_bidi);
+}
+
+template <typename Stub, typename Union, typename Request,
+          typename RequestUnionFactory, typename ResponseUnionFactory,
+          typename AggregateFactory>
+void ExerciseUnions(Stub *stub, const std::vector<Request> &requests,
+                    RequestUnionFactory request_union_factory,
+                    ResponseUnionFactory response_union_factory,
+                    AggregateFactory aggregate_factory) {
+  std::vector<Union> unions;
+  for (const auto &request : requests) {
+    unions.push_back(request_union_factory(request));
+  }
+
+  Union unary_response;
+  ::grpc::ClientContext unary_context;
+  CheckStatus("UnaryUnion", stub->UnaryUnion(&unary_context, unions.front(),
+                                             &unary_response));
+  CheckEqual("UnaryUnion", unary_response,
+             response_union_factory(requests.front(), "unary", 10));
+
+  std::vector<Union> server_responses;
+  ::grpc::ClientContext server_context;
+  auto reader = stub->ServerStreamUnion(&server_context, unions.front());
+  Union server_response;
+  while (reader->Read(&server_response)) {
+    server_responses.push_back(server_response);
+  }
+  CheckStatus("ServerStreamUnion", reader->Finish());
+  CheckEqual("ServerStreamUnion", server_responses,
+             std::vector<Union>{
+                 response_union_factory(requests.front(), "server-0", 0),
+                 response_union_factory(requests.front(), "server-1", 1),
+                 response_union_factory(requests.front(), "server-2", 2)});
+
+  Union client_response;
+  ::grpc::ClientContext client_context;
+  auto writer = stub->ClientStreamUnion(&client_context, &client_response);
+  for (const auto &value : unions) {
+    if (!writer->Write(value)) {
+      throw std::runtime_error("ClientStreamUnion: write failed");
+    }
+  }
+  writer->WritesDone();
+  CheckStatus("ClientStreamUnion", writer->Finish());
+  CheckEqual("ClientStreamUnion", client_response, 
aggregate_factory(requests));
+
+  std::vector<Union> bidi_responses;
+  ::grpc::ClientContext bidi_context;
+  auto stream = stub->BidiStreamUnion(&bidi_context);
+  // Read each echo before sending the next request so synchronous flow control
+  // cannot block both peers.
+  for (const auto &value : unions) {
+    if (!stream->Write(value)) {
+      throw std::runtime_error("BidiStreamUnion: write failed");
+    }
+    Union bidi_response;
+    if (!stream->Read(&bidi_response)) {
+      throw std::runtime_error("BidiStreamUnion: response read failed");
+    }
+    bidi_responses.push_back(bidi_response);
+  }
+  stream->WritesDone();
+  Union extra_bidi_response;
+  if (stream->Read(&extra_bidi_response)) {
+    throw std::runtime_error("BidiStreamUnion: unexpected response");
+  }
+  CheckStatus("BidiStreamUnion", stream->Finish());
+  std::vector<Union> expected_bidi;
+  for (std::size_t index = 0; index < requests.size(); ++index) {
+    expected_bidi.push_back(response_union_factory(
+        requests[index], "bidi-" + std::to_string(index), index));
+  }
+  CheckEqual("BidiStreamUnion", bidi_responses, expected_bidi);
+}
+
+template <typename Request, typename Response, typename Reader>
+::grpc::Status ReadAndAggregate(Reader *reader, Response *response) {
+  std::vector<Request> requests;
+  Request request;
+  while (reader->Read(&request)) {
+    requests.push_back(request);
+  }
+  *response = AggregateStringRequests<Response>(requests);
+  return ::grpc::Status::OK;
+}
+
+template <typename Request, typename Response, typename Stream>
+::grpc::Status EchoStringStream(Stream *stream) {
+  Request request;
+  std::int32_t index = 0;
+  while (stream->Read(&request)) {
+    if (!stream->Write(MakeStringResponse<Response>(
+            request, "bidi-" + std::to_string(index), index))) {
+      return ::grpc::Status(::grpc::StatusCode::UNKNOWN,
+                            "response write failed");
+    }
+    ++index;
+  }
+  return ::grpc::Status::OK;
+}
+
+class FdlService final : public grpc_fdl::service::FdlGrpcService {
+public:
+  ::grpc::Status UnaryMessage(::grpc::ServerContext *,
+                              const grpc_fdl::GrpcFdlRequest *request,
+                              grpc_fdl::GrpcFdlResponse *response) override {
+    *response =
+        MakeStringResponse<grpc_fdl::GrpcFdlResponse>(*request, "unary", 10);
+    return ::grpc::Status::OK;
+  }
+
+  ::grpc::Status ServerStreamMessage(
+      ::grpc::ServerContext *, const grpc_fdl::GrpcFdlRequest *request,
+      ::grpc::ServerWriter<grpc_fdl::GrpcFdlResponse> *writer) override {
+    for (std::int32_t index = 0; index < 3; ++index) {
+      if (!writer->Write(MakeStringResponse<grpc_fdl::GrpcFdlResponse>(
+              *request, "server-" + std::to_string(index), index))) {
+        return ::grpc::Status(::grpc::StatusCode::UNKNOWN,
+                              "response write failed");
+      }
+    }
+    return ::grpc::Status::OK;
+  }
+
+  ::grpc::Status
+  ClientStreamMessage(::grpc::ServerContext *,
+                      ::grpc::ServerReader<grpc_fdl::GrpcFdlRequest> *reader,
+                      grpc_fdl::GrpcFdlResponse *response) override {
+    return ReadAndAggregate<grpc_fdl::GrpcFdlRequest>(reader, response);
+  }
+
+  ::grpc::Status BidiStreamMessage(
+      ::grpc::ServerContext *,
+      ::grpc::ServerReaderWriter<grpc_fdl::GrpcFdlResponse,
+                                 grpc_fdl::GrpcFdlRequest> *stream) override {
+    return EchoStringStream<grpc_fdl::GrpcFdlRequest,
+                            grpc_fdl::GrpcFdlResponse>(stream);
+  }
+
+  ::grpc::Status UnaryUnion(::grpc::ServerContext *,
+                            const grpc_fdl::GrpcFdlUnion *request,
+                            grpc_fdl::GrpcFdlUnion *response) override {
+    const auto *value = request->as_request();
+    if (value == nullptr) {
+      return InvalidUnion();
+    }
+    *response = grpc_fdl::GrpcFdlUnion::response(
+        MakeStringResponse<grpc_fdl::GrpcFdlResponse>(*value, "unary", 10));
+    return ::grpc::Status::OK;
+  }
+
+  ::grpc::Status ServerStreamUnion(
+      ::grpc::ServerContext *, const grpc_fdl::GrpcFdlUnion *request,
+      ::grpc::ServerWriter<grpc_fdl::GrpcFdlUnion> *writer) override {
+    const auto *value = request->as_request();
+    if (value == nullptr) {
+      return InvalidUnion();
+    }
+    for (std::int32_t index = 0; index < 3; ++index) {
+      if (!writer->Write(grpc_fdl::GrpcFdlUnion::response(
+              MakeStringResponse<grpc_fdl::GrpcFdlResponse>(
+                  *value, "server-" + std::to_string(index), index)))) {
+        return ::grpc::Status(::grpc::StatusCode::UNKNOWN,
+                              "response write failed");
+      }
+    }
+    return ::grpc::Status::OK;
+  }
+
+  ::grpc::Status
+  ClientStreamUnion(::grpc::ServerContext *,
+                    ::grpc::ServerReader<grpc_fdl::GrpcFdlUnion> *reader,
+                    grpc_fdl::GrpcFdlUnion *response) override {
+    std::vector<grpc_fdl::GrpcFdlRequest> requests;
+    grpc_fdl::GrpcFdlUnion value;
+    while (reader->Read(&value)) {
+      const auto *request = value.as_request();
+      if (request == nullptr) {
+        return InvalidUnion();
+      }
+      requests.push_back(*request);
+    }
+    *response = grpc_fdl::GrpcFdlUnion::response(
+        AggregateStringRequests<grpc_fdl::GrpcFdlResponse>(requests));
+    return ::grpc::Status::OK;
+  }
+
+  ::grpc::Status BidiStreamUnion(
+      ::grpc::ServerContext *,
+      ::grpc::ServerReaderWriter<grpc_fdl::GrpcFdlUnion, 
grpc_fdl::GrpcFdlUnion>
+          *stream) override {
+    grpc_fdl::GrpcFdlUnion value;
+    std::int32_t index = 0;
+    while (stream->Read(&value)) {
+      const auto *request = value.as_request();
+      if (request == nullptr) {
+        return InvalidUnion();
+      }
+      if (!stream->Write(grpc_fdl::GrpcFdlUnion::response(
+              MakeStringResponse<grpc_fdl::GrpcFdlResponse>(
+                  *request, "bidi-" + std::to_string(index), index)))) {
+        return ::grpc::Status(::grpc::StatusCode::UNKNOWN,
+                              "response write failed");
+      }
+      ++index;
+    }
+    return ::grpc::Status::OK;
+  }
+
+private:
+  static ::grpc::Status InvalidUnion() {
+    return ::grpc::Status(::grpc::StatusCode::INVALID_ARGUMENT,
+                          "expected GrpcFdlUnion request");
+  }
+};
+
+class FbsService final : public grpc_fbs::service::FbsGrpcService {
+public:
+  ::grpc::Status UnaryMessage(::grpc::ServerContext *,
+                              const grpc_fbs::GrpcFbsRequest *request,
+                              grpc_fbs::GrpcFbsResponse *response) override {
+    *response =
+        MakeStringResponse<grpc_fbs::GrpcFbsResponse>(*request, "unary", 10);
+    return ::grpc::Status::OK;
+  }
+
+  ::grpc::Status ServerStreamMessage(
+      ::grpc::ServerContext *, const grpc_fbs::GrpcFbsRequest *request,
+      ::grpc::ServerWriter<grpc_fbs::GrpcFbsResponse> *writer) override {
+    for (std::int32_t index = 0; index < 3; ++index) {
+      if (!writer->Write(MakeStringResponse<grpc_fbs::GrpcFbsResponse>(
+              *request, "server-" + std::to_string(index), index))) {
+        return ::grpc::Status(::grpc::StatusCode::UNKNOWN,
+                              "response write failed");
+      }
+    }
+    return ::grpc::Status::OK;
+  }
+
+  ::grpc::Status
+  ClientStreamMessage(::grpc::ServerContext *,
+                      ::grpc::ServerReader<grpc_fbs::GrpcFbsRequest> *reader,
+                      grpc_fbs::GrpcFbsResponse *response) override {
+    return ReadAndAggregate<grpc_fbs::GrpcFbsRequest>(reader, response);
+  }
+
+  ::grpc::Status BidiStreamMessage(
+      ::grpc::ServerContext *,
+      ::grpc::ServerReaderWriter<grpc_fbs::GrpcFbsResponse,
+                                 grpc_fbs::GrpcFbsRequest> *stream) override {
+    return EchoStringStream<grpc_fbs::GrpcFbsRequest,
+                            grpc_fbs::GrpcFbsResponse>(stream);
+  }
+
+  ::grpc::Status UnaryUnion(::grpc::ServerContext *,
+                            const grpc_fbs::GrpcFbsUnion *request,
+                            grpc_fbs::GrpcFbsUnion *response) override {
+    const auto *value = request->as_grpc_fbs_request();
+    if (value == nullptr) {
+      return InvalidUnion();
+    }
+    *response = grpc_fbs::GrpcFbsUnion::grpc_fbs_response(
+        MakeStringResponse<grpc_fbs::GrpcFbsResponse>(*value, "unary", 10));
+    return ::grpc::Status::OK;
+  }
+
+  ::grpc::Status ServerStreamUnion(
+      ::grpc::ServerContext *, const grpc_fbs::GrpcFbsUnion *request,
+      ::grpc::ServerWriter<grpc_fbs::GrpcFbsUnion> *writer) override {
+    const auto *value = request->as_grpc_fbs_request();
+    if (value == nullptr) {
+      return InvalidUnion();
+    }
+    for (std::int32_t index = 0; index < 3; ++index) {
+      if (!writer->Write(grpc_fbs::GrpcFbsUnion::grpc_fbs_response(
+              MakeStringResponse<grpc_fbs::GrpcFbsResponse>(
+                  *value, "server-" + std::to_string(index), index)))) {
+        return ::grpc::Status(::grpc::StatusCode::UNKNOWN,
+                              "response write failed");
+      }
+    }
+    return ::grpc::Status::OK;
+  }
+
+  ::grpc::Status
+  ClientStreamUnion(::grpc::ServerContext *,
+                    ::grpc::ServerReader<grpc_fbs::GrpcFbsUnion> *reader,
+                    grpc_fbs::GrpcFbsUnion *response) override {
+    std::vector<grpc_fbs::GrpcFbsRequest> requests;
+    grpc_fbs::GrpcFbsUnion value;
+    while (reader->Read(&value)) {
+      const auto *request = value.as_grpc_fbs_request();
+      if (request == nullptr) {
+        return InvalidUnion();
+      }
+      requests.push_back(*request);
+    }
+    *response = grpc_fbs::GrpcFbsUnion::grpc_fbs_response(
+        AggregateStringRequests<grpc_fbs::GrpcFbsResponse>(requests));
+    return ::grpc::Status::OK;
+  }
+
+  ::grpc::Status BidiStreamUnion(
+      ::grpc::ServerContext *,
+      ::grpc::ServerReaderWriter<grpc_fbs::GrpcFbsUnion, 
grpc_fbs::GrpcFbsUnion>
+          *stream) override {
+    grpc_fbs::GrpcFbsUnion value;
+    std::int32_t index = 0;
+    while (stream->Read(&value)) {
+      const auto *request = value.as_grpc_fbs_request();
+      if (request == nullptr) {
+        return InvalidUnion();
+      }
+      if (!stream->Write(grpc_fbs::GrpcFbsUnion::grpc_fbs_response(
+              MakeStringResponse<grpc_fbs::GrpcFbsResponse>(
+                  *request, "bidi-" + std::to_string(index), index)))) {
+        return ::grpc::Status(::grpc::StatusCode::UNKNOWN,
+                              "response write failed");
+      }
+      ++index;
+    }
+    return ::grpc::Status::OK;
+  }
+
+private:
+  static ::grpc::Status InvalidUnion() {
+    return ::grpc::Status(::grpc::StatusCode::INVALID_ARGUMENT,
+                          "expected GrpcFbsUnion request");
+  }
+};
+
+class PbService final : public grpc_pb::service::PbGrpcService {
+public:
+  ::grpc::Status UnaryMessage(::grpc::ServerContext *,
+                              const grpc_pb::GrpcPbRequest *request,
+                              grpc_pb::GrpcPbResponse *response) override {
+    *response = MakePbResponse(*request, "unary", 10);
+    return ::grpc::Status::OK;
+  }
+
+  ::grpc::Status ServerStreamMessage(
+      ::grpc::ServerContext *, const grpc_pb::GrpcPbRequest *request,
+      ::grpc::ServerWriter<grpc_pb::GrpcPbResponse> *writer) override {
+    for (std::uint32_t index = 0; index < 3; ++index) {
+      if (!writer->Write(MakePbResponse(
+              *request, "server-" + std::to_string(index), index))) {
+        return ::grpc::Status(::grpc::StatusCode::UNKNOWN,
+                              "response write failed");
+      }
+    }
+    return ::grpc::Status::OK;
+  }
+
+  ::grpc::Status
+  ClientStreamMessage(::grpc::ServerContext *,
+                      ::grpc::ServerReader<grpc_pb::GrpcPbRequest> *reader,
+                      grpc_pb::GrpcPbResponse *response) override {
+    std::vector<grpc_pb::GrpcPbRequest> requests;
+    grpc_pb::GrpcPbRequest request;
+    while (reader->Read(&request)) {
+      requests.push_back(request);
+    }
+    *response = AggregatePbRequests(requests);
+    return ::grpc::Status::OK;
+  }
+
+  ::grpc::Status BidiStreamMessage(
+      ::grpc::ServerContext *,
+      ::grpc::ServerReaderWriter<grpc_pb::GrpcPbResponse,
+                                 grpc_pb::GrpcPbRequest> *stream) override {
+    grpc_pb::GrpcPbRequest request;
+    std::uint32_t index = 0;
+    while (stream->Read(&request)) {
+      if (!stream->Write(MakePbResponse(
+              request, "bidi-" + std::to_string(index), index))) {
+        return ::grpc::Status(::grpc::StatusCode::UNKNOWN,
+                              "response write failed");
+      }
+      ++index;
+    }
+    return ::grpc::Status::OK;
+  }
+};
+
+void ExerciseFdl(const std::shared_ptr<::grpc::Channel> &channel) {
+  auto stub = grpc_fdl::service::grpc::FdlGrpcServiceStub::NewStub(channel);
+  const std::vector<grpc_fdl::GrpcFdlRequest> requests{
+      MakeStringRequest<grpc_fdl::GrpcFdlRequest>("fdl-a", 1, "alpha"),
+      MakeStringRequest<grpc_fdl::GrpcFdlRequest>("fdl-b", 2, "beta")};
+  ExerciseMessages<grpc_fdl::service::grpc::FdlGrpcServiceStub,
+                   grpc_fdl::GrpcFdlRequest, grpc_fdl::GrpcFdlResponse>(
+      stub.get(), requests,
+      [](const auto &request, const auto &tag, auto offset) {
+        return MakeStringResponse<grpc_fdl::GrpcFdlResponse>(request, tag,
+                                                             offset);
+      },
+      [](const auto &values) {
+        return AggregateStringRequests<grpc_fdl::GrpcFdlResponse>(values);
+      });
+
+  const std::vector<grpc_fdl::GrpcFdlRequest> union_requests{
+      MakeStringRequest<grpc_fdl::GrpcFdlRequest>("fdl-u-a", 3, "union-alpha"),
+      MakeStringRequest<grpc_fdl::GrpcFdlRequest>("fdl-u-b", 4, "union-beta")};
+  ExerciseUnions<grpc_fdl::service::grpc::FdlGrpcServiceStub,
+                 grpc_fdl::GrpcFdlUnion>(
+      stub.get(), union_requests,
+      [](const auto &request) {
+        return grpc_fdl::GrpcFdlUnion::request(request);
+      },
+      [](const auto &request, const auto &tag, auto offset) {
+        return grpc_fdl::GrpcFdlUnion::response(
+            MakeStringResponse<grpc_fdl::GrpcFdlResponse>(request, tag,
+                                                          offset));
+      },
+      [](const auto &values) {
+        return grpc_fdl::GrpcFdlUnion::response(
+            AggregateStringRequests<grpc_fdl::GrpcFdlResponse>(values));
+      });
+}
+
+void ExerciseFbs(const std::shared_ptr<::grpc::Channel> &channel) {
+  auto stub = grpc_fbs::service::grpc::FbsGrpcServiceStub::NewStub(channel);
+  const std::vector<grpc_fbs::GrpcFbsRequest> requests{
+      MakeStringRequest<grpc_fbs::GrpcFbsRequest>("fbs-a", 5, "alpha"),
+      MakeStringRequest<grpc_fbs::GrpcFbsRequest>("fbs-b", 6, "beta")};
+  ExerciseMessages<grpc_fbs::service::grpc::FbsGrpcServiceStub,
+                   grpc_fbs::GrpcFbsRequest, grpc_fbs::GrpcFbsResponse>(
+      stub.get(), requests,
+      [](const auto &request, const auto &tag, auto offset) {
+        return MakeStringResponse<grpc_fbs::GrpcFbsResponse>(request, tag,
+                                                             offset);
+      },
+      [](const auto &values) {
+        return AggregateStringRequests<grpc_fbs::GrpcFbsResponse>(values);
+      });
+
+  const std::vector<grpc_fbs::GrpcFbsRequest> union_requests{
+      MakeStringRequest<grpc_fbs::GrpcFbsRequest>("fbs-u-a", 7, "union-alpha"),
+      MakeStringRequest<grpc_fbs::GrpcFbsRequest>("fbs-u-b", 8, "union-beta")};
+  ExerciseUnions<grpc_fbs::service::grpc::FbsGrpcServiceStub,
+                 grpc_fbs::GrpcFbsUnion>(
+      stub.get(), union_requests,
+      [](const auto &request) {
+        return grpc_fbs::GrpcFbsUnion::grpc_fbs_request(request);
+      },
+      [](const auto &request, const auto &tag, auto offset) {
+        return grpc_fbs::GrpcFbsUnion::grpc_fbs_response(
+            MakeStringResponse<grpc_fbs::GrpcFbsResponse>(request, tag,
+                                                          offset));
+      },
+      [](const auto &values) {
+        return grpc_fbs::GrpcFbsUnion::grpc_fbs_response(
+            AggregateStringRequests<grpc_fbs::GrpcFbsResponse>(values));
+      });
+}
+
+void ExercisePb(const std::shared_ptr<::grpc::Channel> &channel) {
+  auto stub = grpc_pb::service::grpc::PbGrpcServiceStub::NewStub(channel);
+  const std::vector<grpc_pb::GrpcPbRequest> requests{
+      MakePbRequest("pb-a", 9, grpc_pb::GrpcPbRequest::Payload::text("alpha")),
+      MakePbRequest("pb-b", 10, grpc_pb::GrpcPbRequest::Payload::number(42))};
+  ExerciseMessages<grpc_pb::service::grpc::PbGrpcServiceStub,
+                   grpc_pb::GrpcPbRequest, grpc_pb::GrpcPbResponse>(
+      stub.get(), requests,
+      [](const auto &request, const auto &tag, auto offset) {
+        return MakePbResponse(request, tag, offset);
+      },
+      [](const auto &values) { return AggregatePbRequests(values); });
+}
+
+std::string RequiredArgument(const std::vector<std::string> &args,
+                             const std::string &name) {
+  for (std::size_t index = 0; index < args.size(); ++index) {
+    if (args[index] == name) {
+      if (index + 1 == args.size()) {
+        throw std::invalid_argument("missing value for " + name);
+      }
+      return args[index + 1];
+    }
+  }
+  throw std::invalid_argument("missing required argument " + name);
+}
+
+void RunClient(const std::string &target) {
+  auto channel =
+      ::grpc::CreateChannel(target, ::grpc::InsecureChannelCredentials());
+  if (!channel->WaitForConnected(std::chrono::system_clock::now() +
+                                 std::chrono::seconds(30))) {
+    throw std::runtime_error("timed out connecting to " + target);
+  }
+  ExerciseFdl(channel);
+  ExerciseFbs(channel);
+  ExercisePb(channel);
+}
+
+void RunServer(const std::string &port_file) {
+  FdlService fdl_impl;
+  FbsService fbs_impl;
+  PbService pb_impl;
+  grpc_fdl::service::grpc::FdlGrpcServiceServiceGrpc fdl_service(&fdl_impl);
+  grpc_fbs::service::grpc::FbsGrpcServiceServiceGrpc fbs_service(&fbs_impl);
+  grpc_pb::service::grpc::PbGrpcServiceServiceGrpc pb_service(&pb_impl);
+
+  ::grpc::ServerBuilder builder;
+  int port = 0;
+  builder.AddListeningPort("127.0.0.1:0", ::grpc::InsecureServerCredentials(),
+                           &port);
+  builder.RegisterService(&fdl_service);
+  builder.RegisterService(&fbs_service);
+  builder.RegisterService(&pb_service);
+  std::unique_ptr<::grpc::Server> server = builder.BuildAndStart();
+  if (server == nullptr || port == 0) {
+    throw std::runtime_error("failed to start gRPC server");
+  }
+
+  std::ofstream output(port_file);
+  output << port;
+  output.close();
+  if (!output) {
+    throw std::runtime_error("failed to write port file " + port_file);
+  }
+  server->Wait();
+}
+
+} // namespace
+
+int main(int argc, char **argv) {
+  try {
+    const std::vector<std::string> args(argv + 1, argv + argc);
+    if (args.empty()) {
+      throw std::invalid_argument(
+          "usage: grpc_interop client --target HOST:PORT | server "
+          "--port-file PATH");
+    }
+    if (args.front() == "client") {
+      RunClient(RequiredArgument(args, "--target"));
+      return 0;
+    }
+    if (args.front() == "server") {
+      RunServer(RequiredArgument(args, "--port-file"));
+      return 0;
+    }
+    throw std::invalid_argument("unknown mode " + args.front());
+  } catch (const std::exception &error) {
+    std::cerr << error.what() << std::endl;
+    return 1;
+  }
+}
diff --git a/integration_tests/grpc_tests/generate_grpc.py 
b/integration_tests/grpc_tests/generate_grpc.py
index f2950c1fe..931fe9b28 100644
--- a/integration_tests/grpc_tests/generate_grpc.py
+++ b/integration_tests/grpc_tests/generate_grpc.py
@@ -36,6 +36,7 @@ OUTPUTS = {
     "python_sync": TEST_DIR / "python/grpc_sync_tests/generated",
     "go": TEST_DIR / "go/generated",
     "rust": TEST_DIR / "rust/generated/src",
+    "cpp": TEST_DIR / "cpp/generated",
     "csharp": TEST_DIR / "csharp/generated",
     "kotlin": TEST_DIR / "kotlin/src/main/kotlin/generated",
     "dart": TEST_DIR / "dart/lib/generated",
@@ -80,6 +81,7 @@ def main() -> int:
                 f"--python_out={OUTPUTS['python']}",
                 f"--go_out={go_pkg_out}",
                 f"--rust_out={OUTPUTS['rust']}",
+                f"--cpp_out={OUTPUTS['cpp']}",
                 f"--csharp_out={OUTPUTS['csharp']}",
                 f"--kotlin_out={OUTPUTS['kotlin']}",
                 f"--dart_out={OUTPUTS['dart']}",
diff --git 
a/integration_tests/grpc_tests/java/src/test/java/org/apache/fory/grpc_tests/CppGrpcTest.java
 
b/integration_tests/grpc_tests/java/src/test/java/org/apache/fory/grpc_tests/CppGrpcTest.java
new file mode 100644
index 000000000..57bd8d5f7
--- /dev/null
+++ 
b/integration_tests/grpc_tests/java/src/test/java/org/apache/fory/grpc_tests/CppGrpcTest.java
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.fory.grpc_tests;
+
+import io.grpc.Server;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import org.testng.annotations.Test;
+
+public class CppGrpcTest extends GrpcTestBase {
+
+  @Test
+  public void testJavaServerCppClient() throws Exception {
+    Server server = startJavaAllSchemasServer();
+    try {
+      runPeer("cpp-grpc-client", cppCommand("client", "--target",
+                                            "127.0.0.1:" + server.getPort()));
+    } finally {
+      server.shutdownNow();
+      server.awaitTermination(10, TimeUnit.SECONDS);
+    }
+  }
+
+  @Test
+  public void testCppServerJavaClient() throws Exception {
+    exercisePeerServer("cpp-grpc", "C++", "fory-grpc-cpp-",
+                       cppCommand("server"), this::exerciseAllSchemas);
+  }
+
+  private PeerCommand cppCommand(String... args) {
+    Path cppRoot = grpcRoot().resolve("cpp");
+    Path binary = cppRoot.resolve("build").resolve("grpc_interop");
+    List<String> command = new ArrayList<>();
+    command.add(binary.toString());
+    command.addAll(Arrays.asList(args));
+    PeerCommand peerCommand = newPeerCommand(cppRoot, command);
+    putEnv(peerCommand, "ENABLE_FORY_DEBUG_OUTPUT", "1");
+    setLocalhostNoProxy(peerCommand);
+    clearProxyEnv(peerCommand);
+    return peerCommand;
+  }
+}
diff --git a/integration_tests/grpc_tests/run_tests.sh 
b/integration_tests/grpc_tests/run_tests.sh
index 784f2f05e..8afabb374 100755
--- a/integration_tests/grpc_tests/run_tests.sh
+++ b/integration_tests/grpc_tests/run_tests.sh
@@ -21,7 +21,7 @@ set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ROOT_DIR="$(cd "${SCRIPT_DIR}/../.." && pwd)"
-TEST_CLASSES="${1:-PythonAsyncGrpcTest,PythonSyncGrpcTest,RustGrpcTest,GoGrpcTest,KotlinGrpcTest,DartGrpcTest}"
+TEST_CLASSES="${1:-PythonAsyncGrpcTest,PythonSyncGrpcTest,RustGrpcTest,GoGrpcTest,CppGrpcTest,KotlinGrpcTest,DartGrpcTest}"
 
 has_test_class() {
   [[ ",${TEST_CLASSES}," == *",$1,"* ]]
@@ -41,6 +41,10 @@ fi
 if has_test_class "RustGrpcTest"; then
   cargo build --manifest-path "${SCRIPT_DIR}/rust/Cargo.toml" --workspace 
--quiet
 fi
+if has_test_class "CppGrpcTest"; then
+  cmake -S "${SCRIPT_DIR}/cpp" -B "${SCRIPT_DIR}/cpp/build" 
-DCMAKE_BUILD_TYPE=Release
+  cmake --build "${SCRIPT_DIR}/cpp/build" --parallel
+fi
 if has_test_class "KotlinGrpcTest"; then
   cd "${SCRIPT_DIR}/kotlin"
   mvn --no-transfer-progress -DskipTests package


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to