diff --git a/centipede/BUILD b/centipede/BUILD
index 52e507c..a955033 100644
--- a/centipede/BUILD
+++ b/centipede/BUILD
@@ -82,6 +82,20 @@
 #                             C++ libraries
 ################################################################################
 
+cc_library(
+    name = "coverage_symbolizer",
+    srcs = ["coverage_symbolizer.cc"],
+    hdrs = ["coverage_symbolizer.h"],
+    deps = [
+        ":coverage",
+        ":feature",
+        "@com_google_absl//absl/status",
+        "@com_google_absl//absl/status:statusor",
+        "@com_google_absl//absl/strings",
+        "@com_google_absl//absl/strings:str_format",
+    ],
+)
+
 # This lib must have zero non-trivial dependencies (other than libc).
 cc_library(
     name = "int_utils",
@@ -1287,6 +1301,18 @@
 )
 
 cc_test(
+    name = "coverage_symbolizer_test",
+    srcs = ["coverage_symbolizer_test.cc"],
+    deps = [
+        ":coverage_symbolizer",
+        ":feature",
+        "@com_google_absl//absl/status",
+        "@com_google_absl//absl/strings",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
     name = "runner_cmp_trace_test",
     srcs = ["runner_cmp_trace_test.cc"],
     deps = [
diff --git a/centipede/coverage_symbolizer.cc b/centipede/coverage_symbolizer.cc
new file mode 100644
index 0000000..9bfc1d8
--- /dev/null
+++ b/centipede/coverage_symbolizer.cc
@@ -0,0 +1,90 @@
+// Copyright 2023 The Centipede Authors.
+//
+// Licensed 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
+//
+//      https://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 "./centipede/coverage_symbolizer.h"
+
+#include <stddef.h>
+
+#include <functional>
+#include <string>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "./centipede/feature.h"
+#include "./centipede/symbol_table.h"
+
+namespace centipede {
+
+DomainSymbolizer::DomainSymbolizer(size_t domain_id)
+    : domain_id_(domain_id), initialized_(false) {
+  func_ = [domain_id](size_t idx) -> std::string {
+    return absl::StrFormat("unknown symbol: domain_id=%d, idx=%d", domain_id,
+                           idx);
+  };
+}
+
+absl::StatusOr<SymbolTable *>
+DomainSymbolizer::InitializeByPopulatingSymbolTable() {
+  if (initialized_) {
+    return absl::FailedPreconditionError(absl::StrCat(
+        "Already initialized this domain symbolizer for domain_id=",
+        domain_id_));
+  }
+  initialized_ = true;
+  func_ = [this](size_t idx) -> std::string {
+    return symbols_.full_description(idx);
+  };
+  return &symbols_;
+}
+
+absl::Status DomainSymbolizer::InitializeWithSymbolizationFunction(
+    const std::function<std::string(size_t idx)> &func) {
+  if (initialized_) {
+    return absl::FailedPreconditionError(absl::StrCat(
+        "Already initialized this domain symbolizer for domain_id=",
+        domain_id_));
+  }
+  initialized_ = true;
+  func_ = func;
+  return absl::OkStatus();
+}
+
+std::string DomainSymbolizer::GetSymbolForIndex(size_t idx) const {
+  return func_(idx);
+}
+
+CoverageSymbolizer::CoverageSymbolizer() {
+  for (size_t i = 0; i < feature_domains::kLastDomain.domain_id(); ++i) {
+    symbolizers_.emplace_back(/*domain_id=*/i);
+  }
+}
+
+absl::StatusOr<DomainSymbolizer *> CoverageSymbolizer::GetSymbolizerForDomain(
+    feature_domains::Domain domain) {
+  if (domain.domain_id() >= feature_domains::kLastDomain.domain_id()) {
+    return absl::InvalidArgumentError(
+        absl::StrCat("Provided invalid domain_id: ", domain.domain_id()));
+  }
+  return &symbolizers_[domain.domain_id()];
+}
+
+std::string CoverageSymbolizer::GetSymbolForFeature(feature_t feature) const {
+  size_t domain_id = feature_domains::Domain::FeatureToDomainId(feature);
+  size_t domain_index = feature_domains::Domain::FeatureToDomainIndex(feature);
+  return symbolizers_[domain_id].GetSymbolForIndex(domain_index);
+}
+
+}  // namespace centipede
diff --git a/centipede/coverage_symbolizer.h b/centipede/coverage_symbolizer.h
new file mode 100644
index 0000000..b109322
--- /dev/null
+++ b/centipede/coverage_symbolizer.h
@@ -0,0 +1,86 @@
+// Copyright 2023 The Centipede Authors.
+//
+// Licensed 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
+//
+//      https://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.
+
+#ifndef FUZZTEST_CENTIPEDE_COVERAGE_SYMBOLIZER_H_
+#define FUZZTEST_CENTIPEDE_COVERAGE_SYMBOLIZER_H_
+
+#include <stddef.h>
+
+#include <functional>
+#include <string>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "./centipede/feature.h"
+#include "./centipede/symbol_table.h"
+
+namespace centipede {
+
+// Provides symbols for one type of coverage features in a domain.
+// Note: Not thread-safe.
+class DomainSymbolizer {
+ public:
+  // Instantiates a DomainSymbolizer for Domain with `domain_id`.
+  explicit DomainSymbolizer(size_t domain_id);
+
+  // Returns a pointer to a symbol table that can be populated with entries for
+  // coverage features.
+  absl::StatusOr<SymbolTable *> InitializeByPopulatingSymbolTable();
+  // Registers a function to be used for symbolizing coverage features.
+  // Given an index into the domain, the function should return the description
+  // of the feature at that index.
+  absl::Status InitializeWithSymbolizationFunction(
+      const std::function<std::string(size_t idx)> &func);
+
+  // Returns a description of the feature at the provided index in the domain.
+  // If the symbolizer is uninitialized, returns an "unknown feature" message.
+  std::string GetSymbolForIndex(size_t idx) const;
+
+ private:
+  // Holds symbols for coverage features. Unpopulated if initialized with
+  // symbolization function.
+  SymbolTable symbols_;
+  // Function that symbolizes the feature at the provided index `idx`. If
+  // initialized by populating `symbols_`, looks up the relevant symbol in
+  // `symbols_`.
+  std::function<std::string(size_t idx)> func_;
+  // Domain ID of the domain this object symbolizes.
+  size_t domain_id_;
+  // Ensures that we cannot be initialized more than once.
+  bool initialized_;
+};
+
+// Provides symbols for features in any domain.
+// Note: Not thread-safe.
+class CoverageSymbolizer {
+ public:
+  CoverageSymbolizer();
+
+  // Returns pointer to corresponding symbolizer for `domain`.
+  absl::StatusOr<DomainSymbolizer *> GetSymbolizerForDomain(
+      feature_domains::Domain domain);
+
+  // Returns the symbol for `feature`. The symbol will be "unknown feature" for
+  // uninitialized domain symbolizers.
+  std::string GetSymbolForFeature(feature_t feature) const;
+
+ private:
+  // Symbolizers for the valid domains.
+  std::vector<DomainSymbolizer> symbolizers_;
+};
+
+}  // namespace centipede
+
+#endif  // FUZZTEST_CENTIPEDE_COVERAGE_SYMBOLIZER_H_
diff --git a/centipede/coverage_symbolizer_test.cc b/centipede/coverage_symbolizer_test.cc
new file mode 100644
index 0000000..ddcc307
--- /dev/null
+++ b/centipede/coverage_symbolizer_test.cc
@@ -0,0 +1,139 @@
+// Copyright 2023 The Centipede Authors.
+//
+// Licensed 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
+//
+//      https://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 "./centipede/coverage_symbolizer.h"
+
+#include <stddef.h>
+
+#include <string>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "./centipede/feature.h"
+
+namespace centipede {
+namespace {
+
+constexpr size_t kUnusedDomainId = 13;
+
+TEST(DomainSymbolizerTest, InitializeByPopulatingSymbolTable) {
+  DomainSymbolizer symbolizer(kUnusedDomainId);
+  ASSERT_OK_AND_ASSIGN(auto symbols,
+                       symbolizer.InitializeByPopulatingSymbolTable());
+  symbols->AddEntry("func_a", "file_line_col:1");
+  symbols->AddEntry("func_b", "file_line_col:2");
+  symbols->AddEntry("func_c", "file_line_col:3");
+
+  EXPECT_EQ(symbolizer.GetSymbolForIndex(0), "func_a file_line_col:1");
+  EXPECT_EQ(symbolizer.GetSymbolForIndex(2), "func_c file_line_col:3");
+  EXPECT_EQ(symbolizer.GetSymbolForIndex(1), "func_b file_line_col:2");
+}
+
+TEST(DomainSymbolizerTest, InitializeWithSymbolizationFunction) {
+  DomainSymbolizer symbolizer(kUnusedDomainId);
+  ASSERT_OK(symbolizer.InitializeWithSymbolizationFunction(
+      [](size_t idx) { return absl::StrCat(idx, "_llama"); }));
+
+  EXPECT_EQ(symbolizer.GetSymbolForIndex(0), "0_llama");
+  EXPECT_EQ(symbolizer.GetSymbolForIndex(2), "2_llama");
+  EXPECT_EQ(symbolizer.GetSymbolForIndex(1), "1_llama");
+}
+
+TEST(DomainSymbolizerTest, CannotDoubleInitialize) {
+  DomainSymbolizer symbolizer1(kUnusedDomainId);
+  ASSERT_OK(symbolizer1.InitializeByPopulatingSymbolTable());
+  EXPECT_THAT(
+      symbolizer1.InitializeWithSymbolizationFunction(
+          [](size_t idx) { return "never_used"; }),
+      ::testing::status::StatusIs(absl::StatusCode::kFailedPrecondition));
+
+  DomainSymbolizer symbolizer2(kUnusedDomainId);
+  ASSERT_OK(symbolizer2.InitializeWithSymbolizationFunction(
+      [](size_t idx) { return "never_used"; }));
+  EXPECT_THAT(
+      symbolizer2.InitializeByPopulatingSymbolTable(),
+      ::testing::status::StatusIs(absl::StatusCode::kFailedPrecondition));
+
+  DomainSymbolizer symbolizer3(kUnusedDomainId);
+  ASSERT_OK(symbolizer3.InitializeByPopulatingSymbolTable());
+  EXPECT_THAT(
+      symbolizer3.InitializeByPopulatingSymbolTable(),
+      ::testing::status::StatusIs(absl::StatusCode::kFailedPrecondition));
+}
+
+TEST(DomainSymbolizerTest, UnknownSymbolIfUninitialized) {
+  DomainSymbolizer symbolizer(/*domain_id=*/12);
+  std::string expected_symbol = "unknown symbol: domain_id=12, idx=10006";
+  EXPECT_EQ(symbolizer.GetSymbolForIndex(10006), expected_symbol);
+}
+
+TEST(CoverageSymbolizerTest, GetSymbolizerForDomain) {
+  CoverageSymbolizer symbolizers;
+  ASSERT_OK_AND_ASSIGN(auto pc_symbolizer, symbolizers.GetSymbolizerForDomain(
+                                               feature_domains::kPCs));
+  ASSERT_OK_AND_ASSIGN(
+      auto bounded_path_symbolizer,
+      symbolizers.GetSymbolizerForDomain(feature_domains::kBoundedPath));
+  EXPECT_NE(pc_symbolizer, bounded_path_symbolizer);
+
+  ASSERT_OK_AND_ASSIGN(
+      auto same_pc_symbolizer,
+      symbolizers.GetSymbolizerForDomain(feature_domains::kPCs));
+  EXPECT_EQ(pc_symbolizer, same_pc_symbolizer);
+}
+
+TEST(CoverageSymbolizerTest, CannotGetSymbolizerForInvalidDomain) {
+  CoverageSymbolizer symbolizers;
+  EXPECT_THAT(symbolizers.GetSymbolizerForDomain(feature_domains::kLastDomain),
+              ::testing::status::StatusIs(absl::StatusCode::kInvalidArgument));
+  EXPECT_THAT(symbolizers.GetSymbolizerForDomain(feature_domains::Domain(777)),
+              ::testing::status::StatusIs(absl::StatusCode::kInvalidArgument));
+}
+
+TEST(CoverageSymbolizerTest, UnknownSymbolForUninitializedDomains) {
+  CoverageSymbolizer symbolizers;
+  feature_t feature_pc = feature_domains::kPCs.ConvertToMe(7);
+  std::string expected_pc_symbol = "unknown symbol: domain_id=1, idx=7";
+  EXPECT_EQ(symbolizers.GetSymbolForFeature(feature_pc), expected_pc_symbol);
+
+  feature_t feature_8bit = feature_domains::k8bitCounters.ConvertToMe(2);
+  std::string expected_8bit_symbol = "unknown symbol: domain_id=2, idx=2";
+  EXPECT_EQ(symbolizers.GetSymbolForFeature(feature_8bit),
+            expected_8bit_symbol);
+}
+
+TEST(CoverageSymbolizerTest, GetSymbolForFeature) {
+  CoverageSymbolizer symbolizers;
+  ASSERT_OK_AND_ASSIGN(auto pc_symbolizer, symbolizers.GetSymbolizerForDomain(
+                                               feature_domains::kPCs));
+  ASSERT_OK(pc_symbolizer->InitializeWithSymbolizationFunction(
+      [](size_t idx) { return absl::StrCat("pc_", idx); }));
+  ASSERT_OK_AND_ASSIGN(
+      auto bounded_path_symbolizer,
+      symbolizers.GetSymbolizerForDomain(feature_domains::kBoundedPath));
+  ASSERT_OK(bounded_path_symbolizer->InitializeWithSymbolizationFunction(
+      [](size_t idx) { return absl::StrCat("bounded_path_", idx); }));
+
+  feature_t feature_pc = feature_domains::kPCs.ConvertToMe(7);
+  EXPECT_EQ(symbolizers.GetSymbolForFeature(feature_pc), "pc_7");
+
+  feature_t feature_bounded_path = feature_domains::kBoundedPath.ConvertToMe(7);
+  EXPECT_EQ(symbolizers.GetSymbolForFeature(feature_bounded_path),
+            "bounded_path_7");
+}
+
+}  // namespace
+}  // namespace centipede
diff --git a/centipede/feature.h b/centipede/feature.h
index 7c61dec..10072df 100644
--- a/centipede/feature.h
+++ b/centipede/feature.h
@@ -94,6 +94,11 @@
     return feature / kDomainSize;
   }
 
+  // Returns the index into the domain of a feature.
+  static size_t FeatureToDomainIndex(feature_t feature) {
+    return feature % kDomainSize;
+  }
+
  private:
   const size_t domain_id_;
 };