diff --git a/pw_protobuf/codegen_test.cc b/pw_protobuf/codegen_test.cc
index b62ce14..bce8564 100644
--- a/pw_protobuf/codegen_test.cc
+++ b/pw_protobuf/codegen_test.cc
@@ -15,6 +15,7 @@
 
 #include "gtest/gtest.h"
 #include "pw_protobuf/encoder.h"
+#include "pw_stream/memory_stream.h"
 
 // These header files contain the code generated by the pw_protobuf plugin.
 // They are re-generated every time the tests are built and are used by the
@@ -36,47 +37,54 @@
 
 TEST(Codegen, Codegen) {
   std::byte encode_buffer[512];
-  NestedEncoder<20, 20> encoder(encode_buffer);
+  std::byte temp_buffer[512];
+  stream::MemoryWriter writer(encode_buffer);
 
-  Pigweed::Encoder pigweed(&encoder);
+  Pigweed::StreamEncoder pigweed(writer, temp_buffer);
   pigweed.WriteMagicNumber(73);
   pigweed.WriteZiggy(-111);
   pigweed.WriteErrorMessage("not a typewriter");
   pigweed.WriteBin(Pigweed::Protobuf::Binary::ZERO);
 
   {
-    Pigweed::Pigweed::Encoder pigweed_pigweed = pigweed.GetPigweedEncoder();
+    Pigweed::Pigweed::StreamEncoder pigweed_pigweed =
+        pigweed.GetPigweedEncoder();
     pigweed_pigweed.WriteStatus(Bool::FILE_NOT_FOUND);
+
+    ASSERT_EQ(pigweed_pigweed.status(), OkStatus());
   }
 
   {
-    Proto::Encoder proto = pigweed.GetProtoEncoder();
+    Proto::StreamEncoder proto = pigweed.GetProtoEncoder();
     proto.WriteBin(Proto::Binary::OFF);
     proto.WritePigweedPigweedBin(Pigweed::Pigweed::Binary::ZERO);
     proto.WritePigweedProtobufBin(Pigweed::Protobuf::Binary::ZERO);
 
     {
-      Pigweed::Protobuf::Compiler::Encoder meta = proto.GetMetaEncoder();
+      Pigweed::Protobuf::Compiler::StreamEncoder meta = proto.GetMetaEncoder();
       meta.WriteFileName("/etc/passwd");
       meta.WriteStatus(Pigweed::Protobuf::Compiler::Status::FUBAR);
     }
 
     {
-      Pigweed::Encoder nested_pigweed = proto.GetPigweedEncoder();
-      pigweed.WriteErrorMessage("here we go again");
-      pigweed.WriteMagicNumber(616);
+      Pigweed::StreamEncoder nested_pigweed = proto.GetPigweedEncoder();
+      nested_pigweed.WriteErrorMessage("here we go again");
+      nested_pigweed.WriteMagicNumber(616);
 
       {
-        DeviceInfo::Encoder device_info = nested_pigweed.GetDeviceInfoEncoder();
+        DeviceInfo::StreamEncoder device_info =
+            nested_pigweed.GetDeviceInfoEncoder();
 
         {
-          KeyValuePair::Encoder attributes = device_info.GetAttributesEncoder();
+          KeyValuePair::StreamEncoder attributes =
+              device_info.GetAttributesEncoder();
           attributes.WriteKey("version");
           attributes.WriteValue("5.3.1");
         }
 
         {
-          KeyValuePair::Encoder attributes = device_info.GetAttributesEncoder();
+          KeyValuePair::StreamEncoder attributes =
+              device_info.GetAttributesEncoder();
           attributes.WriteKey("chip");
           attributes.WriteValue("left-soc");
         }
@@ -87,7 +95,7 @@
   }
 
   for (int i = 0; i < 5; ++i) {
-    Proto::ID::Encoder id = pigweed.GetIdEncoder();
+    Proto::ID::StreamEncoder id = pigweed.GetIdEncoder();
     id.WriteId(5 * i * i + 3 * i + 49);
   }
 
@@ -166,11 +174,10 @@
   };
   // clang-format on
 
-  Result result = encoder.Encode();
-  ASSERT_EQ(result.status(), OkStatus());
-  EXPECT_EQ(result.value().size(), sizeof(expected_proto));
-  EXPECT_EQ(std::memcmp(
-                result.value().data(), expected_proto, sizeof(expected_proto)),
+  ConstByteSpan result = writer.WrittenData();
+  ASSERT_EQ(pigweed.status(), OkStatus());
+  EXPECT_EQ(result.size(), sizeof(expected_proto));
+  EXPECT_EQ(std::memcmp(result.data(), expected_proto, sizeof(expected_proto)),
             0);
 }
 
@@ -260,9 +267,7 @@
 
 TEST(CodegenRepeated, NonScalar) {
   std::byte encode_buffer[32];
-  NestedEncoder encoder(encode_buffer);
-
-  RepeatedTest::Encoder repeated_test(&encoder);
+  RepeatedTest::RamEncoder repeated_test(encode_buffer);
   constexpr const char* strings[] = {"the", "quick", "brown", "fox"};
   for (const char* s : strings) {
     repeated_test.WriteStrings(s);
@@ -271,11 +276,10 @@
   constexpr uint8_t expected_proto[] = {
       0x1a, 0x03, 't', 'h', 'e', 0x1a, 0x5, 'q',  'u', 'i', 'c', 'k',
       0x1a, 0x5,  'b', 'r', 'o', 'w',  'n', 0x1a, 0x3, 'f', 'o', 'x'};
-  Result result = encoder.Encode();
-  ASSERT_EQ(result.status(), OkStatus());
-  EXPECT_EQ(result.value().size(), sizeof(expected_proto));
-  EXPECT_EQ(std::memcmp(
-                result.value().data(), expected_proto, sizeof(expected_proto)),
+  ConstByteSpan result(repeated_test);
+  ASSERT_EQ(repeated_test.status(), OkStatus());
+  EXPECT_EQ(result.size(), sizeof(expected_proto));
+  EXPECT_EQ(std::memcmp(result.data(), expected_proto, sizeof(expected_proto)),
             0);
 }
 
diff --git a/pw_protobuf/encoding.rst b/pw_protobuf/encoding.rst
index a7259db..340e711 100644
--- a/pw_protobuf/encoding.rst
+++ b/pw_protobuf/encoding.rst
@@ -120,3 +120,95 @@
 While individual write calls on a proto encoder return pw::Status objects, the
 encoder tracks all status returns and "latches" onto the first error
 encountered. This status can be accessed via ``StreamingEncoder::status()``.
+
+Codegen
+-------
+pw_protobuf encoder codegen integration is supported in GN, Bazel, and CMake.
+The codegen is just a light wrapper around the ``StreamEncoder`` and
+``MemoryEncoder`` objects, providing named helper functions to write proto
+fields rather than requiring that field numbers are directly passed to an
+encoder. Namespaced proto enums are also generated, and used as the arguments
+when writing enum fields of a proto message.
+
+All generated messages provide a ``Fields`` enum that can be used directly for
+out-of-band encoding, or with the ``pw::protobuf::Decoder``.
+
+This module's codegen is available through the ``*.pwpb`` sub-target of a
+``pw_proto_library`` in GN, CMake, and Bazel. See :ref:`pw_protobuf_compiler's
+documentation <module-pw_protobuf_compiler>` for more information on build
+system integration for pw_protobuf codegen.
+
+Example ``BUILD.gn``:
+
+.. Code:: none
+
+  import("//build_overrides/pigweed.gni")
+
+  import("$dir_pw_build/target_types.gni")
+  import("$dir_pw_protobuf_compiler/proto.gni")
+
+  # This target controls where the *.pwpb.h headers end up on the include path.
+  # In this example, it's at "pet_daycare_protos/client.pwpb.h".
+  pw_proto_library("pet_daycare_protos") {
+    sources = [
+      "pet_daycare_protos/client.proto",
+    ]
+  }
+
+  pw_source_set("example_client") {
+    sources = [ "example_client.cc" ]
+    deps = [
+      ":pet_daycare_protos.pwpb",
+      dir_pw_bytes,
+      dir_pw_stream,
+    ]
+  }
+
+Example ``pet_daycare_protos/client.proto``:
+
+.. Code:: none
+
+  syntax = "proto3";
+  // The proto package controls the namespacing of the codegen. If this package
+  // were fuzzy.friends, the namespace for codegen would be fuzzy::friends::*.
+  package fuzzy_friends;
+
+  message Pet {
+    string name = 1;
+    string pet_type = 2;
+  }
+
+  message Client {
+    repeated Pet pets = 1;
+  }
+
+Example ``example_client.cc``:
+
+.. Code:: cpp
+
+  #include "pet_daycare_protos/client.pwpb.h"
+  #include "pw_protobuf/streaming_encoder.h"
+  #include "pw_stream/sys_io_stream.h"
+  #include "pw_bytes/span.h"
+
+  pw::stream::SysIoWriter sys_io_writer;
+  std::byte submessage_scratch_buffer[64];
+  // The constructor is the same as a pw::protobuf::StreamingEncoder.
+  fuzzy_friends::Client::StreamEncoder client(sys_io_writer,
+                                              submessage_scratch_buffer);
+
+  fuzzy_friends::Pet::StreamEncoder pet1 = client.GetPetsEncoder();
+
+  pet1.WriteName("Spot");
+  pet1.WritePetType("dog");
+  PW_CHECK_OK(pet1.Finalize());
+
+  {  // Since pet2 is scoped, it will automatically Finalize() on destruction.
+    fuzzy_friends::Pet::StreamEncoder pet2 = client.GetPetsEncoder();
+    pet2.WriteName("Slippers");
+    pet2.WritePetType("rabbit");
+  }
+
+  if (!client.status().ok()) {
+    PW_LOG_INFO("Failed to encode proto; %s", client.status().str());
+  }
diff --git a/pw_protobuf/public/pw_protobuf/streaming_encoder.h b/pw_protobuf/public/pw_protobuf/streaming_encoder.h
index 2e3d761..c19a21f 100644
--- a/pw_protobuf/public/pw_protobuf/streaming_encoder.h
+++ b/pw_protobuf/public/pw_protobuf/streaming_encoder.h
@@ -81,12 +81,11 @@
   ~StreamingEncoder() { Finalize(); }
 
   // Disallow copy/assign to avoid confusion about who owns the buffer.
-  StreamingEncoder(const StreamingEncoder& other) = delete;
   StreamingEncoder& operator=(const StreamingEncoder& other) = delete;
+  StreamingEncoder(const StreamingEncoder& other) = delete;
 
   // It's not safe to move an encoder as it could cause another encoder's
   // parent_ pointer to become invalid.
-  StreamingEncoder(StreamingEncoder&& other) = delete;
   StreamingEncoder& operator=(StreamingEncoder&& other) = delete;
 
   // Forwards the conservative write limit of the underlying pw::stream::Writer.
@@ -362,6 +361,39 @@
     return WriteBytes(field_number, std::as_bytes(std::span(value)));
   }
 
+  // Writes a proto string key-value pair.
+  //
+  // Precondition: Encoder has no active child encoder.
+  Status WriteString(uint32_t field_number, const char* value, size_t len) {
+    return WriteBytes(field_number, std::as_bytes(std::span(value, len)));
+  }
+
+  // Writes a proto string key-value pair.
+  // TODO(384): This function is not safe and will be removed as part of the
+  // transition away from the old protobuf encoder.
+  //
+  // Precondition: Encoder has no active child encoder.
+  Status WriteString(uint32_t field_number, const char* value) {
+    return WriteBytes(field_number,
+                      std::as_bytes(std::span(std::string_view(value))));
+  }
+
+ protected:
+  // We need this for codegen.
+  constexpr StreamingEncoder(StreamingEncoder&& other)
+      : writer_(&other.writer_ == &other.memory_writer_ ? memory_writer_
+                                                        : other.writer_),
+        status_(other.status_),
+        parent_(other.parent_),
+        nested_field_number_(other.nested_field_number_),
+        memory_writer_(std::move(other.memory_writer_)) {
+    PW_ASSERT(nested_field_number_ == 0);
+    // Make the nested encoder look like it has an open child to block writes
+    // for the remainder of the object's life.
+    other.nested_field_number_ = kFirstReservedNumber;
+    other.parent_ = nullptr;
+  }
+
  private:
   friend class MemoryEncoder;
 
@@ -518,11 +550,14 @@
 
   // It's not safe to move an encoder as it could cause another encoder's
   // parent_ pointer to become invalid.
-  MemoryEncoder(MemoryEncoder&& other) = delete;
   MemoryEncoder& operator=(MemoryEncoder&& other) = delete;
 
   const std::byte* data() const { return memory_writer_.data(); }
   size_t size() const { return memory_writer_.bytes_written(); }
+
+ protected:
+  // This is needed by codegen.
+  MemoryEncoder(MemoryEncoder&& other) = default;
 };
 
 }  // namespace pw::protobuf
diff --git a/pw_protobuf/py/pw_protobuf/codegen_pwpb.py b/pw_protobuf/py/pw_protobuf/codegen_pwpb.py
index e0b9293..d103018 100644
--- a/pw_protobuf/py/pw_protobuf/codegen_pwpb.py
+++ b/pw_protobuf/py/pw_protobuf/codegen_pwpb.py
@@ -15,6 +15,7 @@
 
 import abc
 from datetime import datetime
+import enum
 import os
 import sys
 from typing import Dict, Iterable, List, Tuple
@@ -34,7 +35,35 @@
 PROTO_CC_EXTENSION = '.pwpb.cc'
 
 PROTOBUF_NAMESPACE = 'pw::protobuf'
-BASE_PROTO_CLASS = 'ProtoMessageEncoder'
+
+
+class EncoderType(enum.Enum):
+    MEMORY = 1
+    STREAMING = 2
+    LEGACY = 3
+
+    def base_class_name(self) -> str:
+        """Returns the base class used by this encoder type."""
+        if self is self.LEGACY:
+            return 'ProtoMessageEncoder'
+        if self is self.STREAMING:
+            return 'StreamingEncoder'
+        if self is self.MEMORY:
+            return 'MemoryEncoder'
+
+        raise ValueError('Unknown encoder type')
+
+    def codegen_class_name(self) -> str:
+        """Returns the base class used by this encoder type."""
+        if self is self.LEGACY:
+            return 'Encoder'
+        if self is self.STREAMING:
+            return 'StreamEncoder'
+        if self is self.MEMORY:
+            # TODO(pwbug/384): Make this the 'Encoder'
+            return 'RamEncoder'
+
+        raise ValueError('Unknown encoder type')
 
 
 # protoc captures stdout, so we need to printf debug to stderr.
@@ -73,7 +102,7 @@
         """
 
     @abc.abstractmethod
-    def body(self) -> List[str]:
+    def body(self, encoder_type: EncoderType) -> List[str]:
         """Returns the method body as a list of source code lines.
 
         e.g.
@@ -84,7 +113,9 @@
         """
 
     @abc.abstractmethod
-    def return_type(self, from_root: bool = False) -> str:
+    def return_type(self,
+                    encoder_type: EncoderType,
+                    from_root: bool = False) -> str:
         """Returns the return type of the method, e.g. int.
 
         For non-primitive return types, the from_root argument determines
@@ -134,15 +165,27 @@
     def name(self) -> str:
         return 'Get{}Encoder'.format(self._field.name())
 
-    def return_type(self, from_root: bool = False) -> str:
-        return '{}::Encoder'.format(self._relative_type_namespace(from_root))
+    def return_type(self,
+                    encoder_type: EncoderType,
+                    from_root: bool = False) -> str:
+        if encoder_type == EncoderType.LEGACY:
+            return '{}::Encoder'.format(
+                self._relative_type_namespace(from_root))
+
+        return '{}::StreamEncoder'.format(
+            self._relative_type_namespace(from_root))
 
     def params(self) -> List[Tuple[str, str]]:
         return []
 
-    def body(self) -> List[str]:
-        line = 'return {}::Encoder(encoder_, {});'.format(
-            self._relative_type_namespace(), self.field_cast())
+    def body(self, encoder_type: EncoderType) -> List[str]:
+        line: str = ''
+        if encoder_type == EncoderType.LEGACY:
+            line = 'return {}::Encoder(encoder_, {});'.format(
+                self._relative_type_namespace(), self.field_cast())
+        else:
+            line = 'return {}::StreamEncoder(GetNestedEncoder({}));'.format(
+                self._relative_type_namespace(), self.field_cast())
         return [line]
 
     # Submessage methods are not defined within the class itself because the
@@ -164,13 +207,19 @@
     def name(self) -> str:
         return 'Write{}'.format(self._field.name())
 
-    def return_type(self, from_root: bool = False) -> str:
+    def return_type(self,
+                    encoder_type: EncoderType,
+                    from_root: bool = False) -> str:
         return '::pw::Status'
 
-    def body(self) -> List[str]:
+    def body(self, encoder_type: EncoderType) -> List[str]:
         params = ', '.join([pair[1] for pair in self.params()])
-        line = 'return encoder_->{}({}, {});'.format(self._encoder_fn(),
-                                                     self.field_cast(), params)
+        if encoder_type == EncoderType.LEGACY:
+            line = 'return encoder_->{}({}, {});'.format(
+                self._encoder_fn(), self.field_cast(), params)
+        else:
+            line = 'return {}({}, {});'.format(self._encoder_fn(),
+                                               self.field_cast(), params)
         return [line]
 
     def params(self) -> List[Tuple[str, str]]:
@@ -465,9 +514,14 @@
     def params(self) -> List[Tuple[str, str]]:
         return [(self._relative_type_namespace(), 'value')]
 
-    def body(self) -> List[str]:
-        line = 'return encoder_->WriteUint32(' \
-            '{}, static_cast<uint32_t>(value));'.format(self.field_cast())
+    def body(self, encoder_type: EncoderType) -> List[str]:
+        line: str = ''
+        if encoder_type == EncoderType.LEGACY:
+            line = 'return encoder_->WriteUint32(' \
+                '{}, static_cast<uint32_t>(value));'.format(self.field_cast())
+        else:
+            line = 'return WriteUint32(' \
+                '{}, static_cast<uint32_t>(value));'.format(self.field_cast())
         return [line]
 
     def in_class_definition(self) -> bool:
@@ -514,20 +568,33 @@
 
 
 def generate_code_for_message(message: ProtoMessage, root: ProtoNode,
-                              output: OutputFile) -> None:
+                              output: OutputFile,
+                              encoder_type: EncoderType) -> None:
     """Creates a C++ class for a protobuf message."""
     assert message.type() == ProtoNode.Type.MESSAGE
 
+    base_class_name = encoder_type.base_class_name()
+    encoder_name = encoder_type.codegen_class_name()
+
     # Message classes inherit from the base proto message class in codegen.h
     # and use its constructor.
-    base_class = f'{PROTOBUF_NAMESPACE}::{BASE_PROTO_CLASS}'
+    base_class = f'{PROTOBUF_NAMESPACE}::{base_class_name}'
     output.write_line(
-        f'class {message.cpp_namespace(root)}::Encoder : public {base_class} {{'
+        f'class {message.cpp_namespace(root)}::{encoder_name} ' \
+        f': public {base_class} {{'
     )
     output.write_line(' public:')
 
     with output.indent():
-        output.write_line(f'using {BASE_PROTO_CLASS}::{BASE_PROTO_CLASS};')
+        # Inherit the constructors from the base encoder.
+        output.write_line(f'using {base_class_name}::{base_class_name};')
+
+        # Declare a move constructor that takes a base encoder.
+        if encoder_type != EncoderType.LEGACY:
+            output.write_line(
+                f'constexpr {encoder_name}({base_class_name}&& parent) '\
+                f': {base_class_name}(std::move(parent)) {{}}'
+            )
 
         # Generate methods for each of the message's fields.
         for field in message.fields():
@@ -538,7 +605,7 @@
 
                 output.write_line()
                 method_signature = (
-                    f'{method.return_type()} '
+                    f'{method.return_type(encoder_type)} '
                     f'{method.name()}({method.param_string()})')
 
                 if not method.in_class_definition():
@@ -549,7 +616,7 @@
 
                 output.write_line(f'{method_signature} {{')
                 with output.indent():
-                    for line in method.body():
+                    for line in method.body(encoder_type):
                         output.write_line(line)
                 output.write_line('}')
 
@@ -557,7 +624,8 @@
 
 
 def define_not_in_class_methods(message: ProtoMessage, root: ProtoNode,
-                                output: OutputFile) -> None:
+                                output: OutputFile,
+                                encoder_type: EncoderType) -> None:
     """Defines methods for a message class that were previously declared."""
     assert message.type() == ProtoNode.Type.MESSAGE
 
@@ -568,25 +636,26 @@
                 continue
 
             output.write_line()
-            class_name = f'{message.cpp_namespace(root)}::Encoder'
+            class_name = (f'{message.cpp_namespace(root)}::'
+                          f'{encoder_type.codegen_class_name()}')
             method_signature = (
-                f'inline {method.return_type(from_root=True)} '
+                f'inline {method.return_type(encoder_type, from_root=True)} '
                 f'{class_name}::{method.name()}({method.param_string()})')
             output.write_line(f'{method_signature} {{')
             with output.indent():
-                for line in method.body():
+                for line in method.body(encoder_type):
                     output.write_line(line)
             output.write_line('}')
 
 
-def generate_code_for_enum(enum: ProtoEnum, root: ProtoNode,
+def generate_code_for_enum(proto_enum: ProtoEnum, root: ProtoNode,
                            output: OutputFile) -> None:
     """Creates a C++ enum for a proto enum."""
-    assert enum.type() == ProtoNode.Type.ENUM
+    assert proto_enum.type() == ProtoNode.Type.ENUM
 
-    output.write_line(f'enum class {enum.cpp_namespace(root)} {{')
+    output.write_line(f'enum class {proto_enum.cpp_namespace(root)} {{')
     with output.indent():
-        for name, number in enum.values():
+        for name, number in proto_enum.values():
             output.write_line(f'{name} = {number},')
     output.write_line('};')
 
@@ -608,6 +677,9 @@
     # Declare the message's encoder class and all of its enums.
     output.write_line()
     output.write_line('class Encoder;')
+    output.write_line('class StreamEncoder;')
+    output.write_line('class RamEncoder;')
+
     for child in node.children():
         if child.type() == ProtoNode.Type.ENUM:
             output.write_line()
@@ -616,6 +688,23 @@
     output.write_line(f'}}  // namespace {namespace}')
 
 
+def generate_encoder_wrappers(package: ProtoNode, encoder_type: EncoderType,
+                              output: OutputFile):
+    # Run through all messages in the file, generating a class for each.
+    for node in package:
+        if node.type() == ProtoNode.Type.MESSAGE:
+            output.write_line()
+            generate_code_for_message(cast(ProtoMessage, node), package,
+                                      output, encoder_type)
+
+    # Run a second pass through the classes, this time defining all of the
+    # methods which were previously only declared.
+    for node in package:
+        if node.type() == ProtoNode.Type.MESSAGE:
+            define_not_in_class_methods(cast(ProtoMessage, node), package,
+                                        output, encoder_type)
+
+
 def _proto_filename_to_generated_header(proto_file: str) -> str:
     """Returns the generated C++ header name for a .proto file."""
     return os.path.splitext(proto_file)[0] + PROTO_H_EXTENSION
@@ -635,6 +724,7 @@
     output.write_line('#include <cstdint>')
     output.write_line('#include <span>\n')
     output.write_line('#include "pw_protobuf/codegen.h"')
+    output.write_line('#include "pw_protobuf/streaming_encoder.h"')
 
     for imported_file in file_descriptor_proto.dependency:
         generated_header = _proto_filename_to_generated_header(imported_file)
@@ -657,19 +747,9 @@
             output.write_line()
             generate_code_for_enum(cast(ProtoEnum, node), package, output)
 
-    # Run through all messages in the file, generating a class for each.
-    for node in package:
-        if node.type() == ProtoNode.Type.MESSAGE:
-            output.write_line()
-            generate_code_for_message(cast(ProtoMessage, node), package,
-                                      output)
-
-    # Run a second pass through the classes, this time defining all of the
-    # methods which were previously only declared.
-    for node in package:
-        if node.type() == ProtoNode.Type.MESSAGE:
-            define_not_in_class_methods(cast(ProtoMessage, node), package,
-                                        output)
+    generate_encoder_wrappers(package, EncoderType.LEGACY, output)
+    generate_encoder_wrappers(package, EncoderType.STREAMING, output)
+    generate_encoder_wrappers(package, EncoderType.MEMORY, output)
 
     if package.cpp_namespace():
         output.write_line(f'\n}}  // namespace {package.cpp_namespace()}')
diff --git a/pw_protobuf_compiler/docs.rst b/pw_protobuf_compiler/docs.rst
index fc9ed7b..99e3d18 100644
--- a/pw_protobuf_compiler/docs.rst
+++ b/pw_protobuf_compiler/docs.rst
@@ -33,10 +33,9 @@
 
 GN template
 ===========
-The ``pw_proto_library`` GN template is provided by the module.
-
-It defines a collection of protobuf files that should be compiled together. The
-template creates a sub-target for each supported generator, named
+This module provides a ``pw_proto_library`` GN template that defines a
+collection of protobuf files that should be compiled together. The template
+creates a sub-target for each supported generator, named
 ``<target_name>.<generator>``. These sub-targets generate their respective
 protobuf code, and expose it to the build system appropriately (e.g. a
 ``pw_source_set`` for C/C++).
@@ -72,6 +71,20 @@
   //path/to/my_protos:my_protos.python.lint
   //path/to/my_protos:python.lint
 
+**Supported Codegen**
+
+GN supports the following compiled proto libraries via the specified
+sub-targets generated by a ``pw_proto_library``.
+
+* ``${target_name}.pwpb`` - Generated C++ pw_protobuf code
+* ``${target_name}.nanopb`` - Generated C++ nanopb code (requires Nanopb)
+* ``${target_name}.nanopb_rpc`` - Generated C++ Nanopb pw_rpc code (requires
+  Nanopb)
+* ``${target_name}.raw_rpc`` - Generated C++ raw pw_rpc code (no protobuf
+  library)
+* ``${target_name}.go`` - Generated GO protobuf libraries
+* ``${target_name}.python`` - Generated Python protobuf libraries
+
 **Arguments**
 
 * ``sources``: List of input .proto files.
@@ -303,6 +316,16 @@
 
   #include "my_other_protos/baz.pwpb.h"
 
+**Supported Codegen**
+
+CMake supports the following compiled proto libraries via the specified
+sub-targets generated by a ``pw_proto_library``.
+
+* ``${NAME}.pwpb`` - Generated C++ pw_protobuf code
+* ``${NAME}.nanopb`` - Generated C++ nanopb code (requires Nanopb)
+* ``${NAME}.nanopb_rpc`` - Generated C++ Nanopb pw_rpc code (requires Nanopb)
+* ``${NAME}.raw_rpc`` - Generated C++ raw pw_rpc code (no protobuf library)
+
 Bazel
 =====
 Bazel provides a ``pw_proto_library`` rule with similar features as the
@@ -356,4 +379,14 @@
 
 .. code:: cpp
 
-  #include "my_protos/bar.pwpb.h"
\ No newline at end of file
+  #include "my_protos/bar.pwpb.h"
+
+**Supported Codegen**
+
+Bazel supports the following compiled proto libraries via the specified
+sub-targets generated by a ``pw_proto_library``.
+
+* ``${NAME}.pwpb`` - Generated C++ pw_protobuf code
+* ``${NAME}.nanopb`` - Generated C++ nanopb code (requires Nanopb)
+* ``${NAME}.nanopb_rpc`` - Generated C++ Nanopb pw_rpc code (requires Nanopb)
+* ``${NAME}.raw_rpc`` - Generated C++ raw pw_rpc code (no protobuf library)