diff --git a/BUILD.gn b/BUILD.gn
index 547b74a401..c6cafcb62e 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -75,6 +75,13 @@ config("tint_public_config") {
   ]
 }
 
+config("tint_config") {
+  include_dirs = []
+  if (tint_build_spv_reader || tint_build_spv_writer) {
+    include_dirs += [ "${tint_spirv_tools_dir}/include/" ]
+  }
+}
+
 ###############################################################################
 # Generated - Generated source files
 ###############################################################################
@@ -1306,38 +1313,114 @@ if (build_with_chromium) {
   # source_set.
 
   source_set("tint_fuzzer_common") {
-    configs += [ ":tint_common_config" ]
-    public_configs = [ ":tint_public_config" ]
+    public_configs = [
+      ":tint_config",
+      ":tint_common_config",
+      ":tint_public_config",
+    ]
+
+    public_deps = [ ":libtint" ]
+
+    sources = [
+      "fuzzers/tint_common_fuzzer.cc",
+      "fuzzers/tint_common_fuzzer.h",
+    ]
   }
 
   if (tint_build_wgsl_reader) {
     fuzzer_test("tint_wgsl_reader_fuzzer") {
       sources = [ "fuzzers/tint_wgsl_reader_fuzzer.cc" ]
-      deps = [
-        ":libtint_wgsl_reader_src",
-        ":tint_fuzzer_common",
-      ]
+      deps = [ ":tint_fuzzer_common" ]
+    }
+  }
+
+  if (tint_build_wgsl_reader && tint_build_wgsl_writer) {
+    fuzzer_test("tint_wgsl_reader_wgsl_writer_fuzzer") {
+      sources = [ "fuzzers/tint_wgsl_reader_wgsl_writer_fuzzer.cc" ]
+      deps = [ ":tint_fuzzer_common" ]
+    }
+  }
+
+  if (tint_build_wgsl_reader && tint_build_spv_writer) {
+    fuzzer_test("tint_wgsl_reader_spv_writer_fuzzer") {
+      sources = [ "fuzzers/tint_wgsl_reader_spv_writer_fuzzer.cc" ]
+      deps = [ ":tint_fuzzer_common" ]
+    }
+
+    fuzzer_test("tint_all_transforms_fuzzer") {
+      sources = [ "fuzzers/tint_all_transforms_fuzzer.cc" ]
+      deps = [ ":tint_fuzzer_common" ]
+    }
+
+    fuzzer_test("tint_bound_array_accessors_fuzzer") {
+      sources = [ "fuzzers/tint_bound_array_accessors_fuzzer.cc" ]
+      deps = [ ":tint_fuzzer_common" ]
+    }
+
+    fuzzer_test("tint_emit_vertex_point_size_fuzzer") {
+      sources = [ "fuzzers/tint_emit_vertex_point_size_fuzzer.cc" ]
+      deps = [ ":tint_fuzzer_common" ]
+    }
+
+    fuzzer_test("tint_first_index_offset_fuzzer") {
+      sources = [ "fuzzers/tint_first_index_offset_fuzzer.cc" ]
+      deps = [ ":tint_fuzzer_common" ]
+    }
+  }
+
+  if (tint_build_wgsl_reader && tint_build_hlsl_writer) {
+    fuzzer_test("tint_wgsl_reader_hlsl_writer_fuzzer") {
+      sources = [ "fuzzers/tint_wgsl_reader_hlsl_writer_fuzzer.cc" ]
+      deps = [ ":tint_fuzzer_common" ]
+    }
+  }
+
+  if (tint_build_wgsl_reader && tint_build_msl_writer) {
+    fuzzer_test("tint_wgsl_reader_msl_writer_fuzzer") {
+      sources = [ "fuzzers/tint_wgsl_reader_msl_writer_fuzzer.cc" ]
+      deps = [ ":tint_fuzzer_common" ]
     }
   }
 
   if (tint_build_spv_reader) {
     fuzzer_test("tint_spv_reader_fuzzer") {
       sources = [ "fuzzers/tint_spv_reader_fuzzer.cc" ]
-      deps = [
-        ":libtint_spv_reader_src",
-        ":tint_fuzzer_common",
-      ]
+      deps = [ ":tint_fuzzer_common" ]
+    }
+  }
+
+  if (tint_build_spv_reader && tint_build_wgsl_writer) {
+    fuzzer_test("tint_spv_reader_wgsl_writer_fuzzer") {
+      sources = [ "fuzzers/tint_spv_reader_wgsl_writer_fuzzer.cc" ]
+      deps = [ ":tint_fuzzer_common" ]
+    }
+  }
+
+  if (tint_build_spv_reader && tint_build_spv_writer) {
+    fuzzer_test("tint_spv_reader_spv_writer_fuzzer") {
+      sources = [ "fuzzers/tint_spv_reader_spv_writer_fuzzer.cc" ]
+      deps = [ ":tint_fuzzer_common" ]
+    }
+  }
+
+  if (tint_build_spv_reader && tint_build_hlsl_writer) {
+    fuzzer_test("tint_spv_reader_hlsl_writer_fuzzer") {
+      sources = [ "fuzzers/tint_spv_reader_hlsl_writer_fuzzer.cc" ]
+      deps = [ ":tint_fuzzer_common" ]
+    }
+  }
+
+  if (tint_build_spv_reader && tint_build_msl_writer) {
+    fuzzer_test("tint_spv_reader_msl_writer_fuzzer") {
+      sources = [ "fuzzers/tint_spv_reader_msl_writer_fuzzer.cc" ]
+      deps = [ ":tint_fuzzer_common" ]
     }
   }
 
   if (tint_build_wgsl_reader && tint_build_wgsl_writer) {
     fuzzer_test("tint_ast_clone_fuzzer") {
       sources = [ "fuzzers/tint_ast_clone_fuzzer.cc" ]
-      deps = [
-        ":libtint_wgsl_reader_src",
-        ":libtint_wgsl_writer_src",
-        ":tint_fuzzer_common",
-      ]
+      deps = [ ":tint_fuzzer_common" ]
     }
   }
 }
@@ -1346,13 +1429,6 @@ if (build_with_chromium) {
 # Samples - Executables exposing command line functionality
 ###############################################################################
 
-config("tint_config") {
-  include_dirs = []
-  if (tint_build_spv_reader || tint_build_spv_writer) {
-    include_dirs += [ "${tint_spirv_tools_dir}/include/" ]
-  }
-}
-
 executable("tint") {
   sources = [ "samples/main.cc" ]
   deps = [
diff --git a/fuzzers/CMakeLists.txt b/fuzzers/CMakeLists.txt
index bfa50e7604..50b43a1e32 100644
--- a/fuzzers/CMakeLists.txt
+++ b/fuzzers/CMakeLists.txt
@@ -13,20 +13,59 @@
 # limitations under the License.
 
 function(add_tint_fuzzer NAME)
-  add_executable(${NAME} ${NAME}.cc)
+  add_executable(${NAME}
+    ${NAME}.cc
+    tint_common_fuzzer.cc)
   target_link_libraries(${NAME} libtint-fuzz)
   tint_default_compile_options(${NAME})
   target_compile_options(${NAME} PRIVATE -Wno-missing-prototypes)
 endfunction()
 
-if (${TINT_BUILD_WGSL_READER})
+if ({$TINT_BUILD_WGSL_READER})
   add_tint_fuzzer(tint_wgsl_reader_fuzzer)
 endif()
 
+if ({$TINT_BUILD_WGSL_READER} AND ${TINT_BUILD_WGSL_WRITER})
+  add_tint_fuzzer(tint_wgsl_reader_wgsl_writer_fuzzer)
+endif()
+
+if ({$TINT_BUILD_WGSL_READER} AND ${TINT_BUILD_SPV_WRITER})
+  add_tint_fuzzer(tint_all_transforms_fuzzer)
+  add_tint_fuzzer(tint_bound_array_accessors_fuzzer)
+  add_tint_fuzzer(tint_emit_vertex_point_size_fuzzer)
+  add_tint_fuzzer(tint_first_index_offset_fuzzer)
+  add_tint_fuzzer(tint_wgsl_reader_spv_writer_fuzzer)
+endif()
+
+if ({$TINT_BUILD_WGSL_READER} AND ${TINT_BUILD_HLSL_WRITER})
+  add_tint_fuzzer(tint_wgsl_reader_hlsl_writer_fuzzer)
+endif()
+
+if ({$TINT_BUILD_WGSL_READER} AND ${TINT_BUILD_MSL_WRITER})
+  add_tint_fuzzer(tint_wgsl_reader_msl_writer_fuzzer)
+endif()
+
 if (${TINT_BUILD_SPV_READER})
   add_tint_fuzzer(tint_spv_reader_fuzzer)
 endif()
 
+if (${TINT_BUILD_SPV_READER} AND ${TINT_BUILD_WGSL_WRITER})
+  add_tint_fuzzer(tint_spv_reader_wgsl_writer_fuzzer)
+endif()
+
+if (${TINT_BUILD_SPV_READER} AND ${TINT_BUILD_SPV_WRITER})
+  add_tint_fuzzer(tint_spv_reader_spv_writer_fuzzer)
+endif()
+
+if (${TINT_BUILD_SPV_READER} AND ${TINT_BUILD_HLSL_WRITER})
+  add_tint_fuzzer(tint_spv_reader_hlsl_writer_fuzzer)
+endif()
+
+if (${TINT_BUILD_SPV_READER} AND ${TINT_BUILD_MSL_WRITER})
+  add_tint_fuzzer(tint_spv_reader_msl_writer_fuzzer)
+endif()
+
+
 if (${TINT_BUILD_WGSL_READER} AND ${TINT_BUILD_WGSL_WRITER})
   add_tint_fuzzer(tint_ast_clone_fuzzer)
 endif()
diff --git a/fuzzers/tint_all_transforms_fuzzer.cc b/fuzzers/tint_all_transforms_fuzzer.cc
new file mode 100644
index 0000000000..0fb4f336d6
--- /dev/null
+++ b/fuzzers/tint_all_transforms_fuzzer.cc
@@ -0,0 +1,36 @@
+// Copyright 2021 The Tint 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
+//
+//     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 "fuzzers/tint_common_fuzzer.h"
+
+namespace tint {
+namespace fuzzers {
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  tint::transform::Manager transform_manager;
+  transform_manager.append(
+      std::make_unique<tint::transform::BoundArrayAccessors>());
+  transform_manager.append(
+      std::make_unique<tint::transform::EmitVertexPointSize>());
+  transform_manager.append(
+      std::make_unique<tint::transform::FirstIndexOffset>(0, 0));
+
+  tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kSpv);
+  fuzzer.SetTransformManager(&transform_manager);
+
+  return fuzzer.Run(data, size);
+}
+
+}  // namespace fuzzers
+}  // namespace tint
diff --git a/fuzzers/tint_bound_array_accessors_fuzzer.cc b/fuzzers/tint_bound_array_accessors_fuzzer.cc
new file mode 100644
index 0000000000..7bb09d1671
--- /dev/null
+++ b/fuzzers/tint_bound_array_accessors_fuzzer.cc
@@ -0,0 +1,32 @@
+// Copyright 2021 The Tint 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
+//
+//     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 "fuzzers/tint_common_fuzzer.h"
+
+namespace tint {
+namespace fuzzers {
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  tint::transform::Manager transform_manager;
+  transform_manager.append(
+      std::make_unique<tint::transform::BoundArrayAccessors>());
+
+  tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kSpv);
+  fuzzer.SetTransformManager(&transform_manager);
+
+  return fuzzer.Run(data, size);
+}
+
+}  // namespace fuzzers
+}  // namespace tint
diff --git a/fuzzers/tint_common_fuzzer.cc b/fuzzers/tint_common_fuzzer.cc
new file mode 100644
index 0000000000..a43ac9af20
--- /dev/null
+++ b/fuzzers/tint_common_fuzzer.cc
@@ -0,0 +1,134 @@
+// Copyright 2021 The Tint 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
+//
+//     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 "fuzzers/tint_common_fuzzer.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace tint {
+namespace fuzzers {
+
+CommonFuzzer::CommonFuzzer(InputFormat input, OutputFormat output)
+    : input_(input), output_(output) {}
+CommonFuzzer::~CommonFuzzer() = default;
+
+int CommonFuzzer::Run(const uint8_t* data, size_t size) {
+  std::unique_ptr<tint::reader::Reader> parser;
+#if TINT_BUILD_WGSL_READER
+  std::unique_ptr<tint::Source::File> file;
+#endif  // TINT_BUILD_WGSL_READER
+
+  switch (input_) {
+    case InputFormat::kWGSL:
+#if TINT_BUILD_WGSL_READER
+    {
+      std::string str(reinterpret_cast<const char*>(data), size);
+
+      file = std::make_unique<tint::Source::File>("test.wgsl", str);
+      parser = std::make_unique<tint::reader::wgsl::Parser>(file.get());
+    }
+#endif  // TINT_BUILD_WGSL_READER
+    break;
+    case InputFormat::kSpv:
+#if TINT_BUILD_SPV_READER
+    {
+      size_t sizeInU32 = size / sizeof(uint32_t);
+      const uint32_t* u32Data = reinterpret_cast<const uint32_t*>(data);
+      std::vector<uint32_t> input(u32Data, u32Data + sizeInU32);
+
+      if (input.size() != 0) {
+        parser = std::make_unique<tint::reader::spirv::Parser>(input);
+      }
+    }
+#endif  // TINT_BUILD_WGSL_READER
+    break;
+    default:
+      break;
+  }
+
+  if (!parser) {
+    return 0;
+  }
+
+  if (!parser->Parse()) {
+    return 0;
+  }
+
+  if (output_ == OutputFormat::kNone) {
+    return 0;
+  }
+
+  auto mod = parser->module();
+  if (!mod.IsValid()) {
+    return 0;
+  }
+
+  tint::TypeDeterminer td(&mod);
+  if (!td.Determine()) {
+    return 0;
+  }
+
+  tint::Validator v;
+  if (!v.Validate(&mod)) {
+    return 0;
+  }
+
+  if (transform_manager_) {
+    auto out = transform_manager_->Run(&mod);
+    if (out.diagnostics.contains_errors()) {
+      return 0;
+    }
+
+    mod = std::move(out.module);
+  }
+
+  std::unique_ptr<tint::writer::Writer> writer;
+
+  switch (output_) {
+    case OutputFormat::kWGSL:
+#if TINT_BUILD_WGSL_WRITER
+      writer = std::make_unique<tint::writer::wgsl::Generator>(std::move(mod));
+#endif  // TINT_BUILD_WGSL_WRITER
+      break;
+    case OutputFormat::kSpv:
+#if TINT_BUILD_SPV_WRITER
+      writer = std::make_unique<tint::writer::spirv::Generator>(std::move(mod));
+#endif  // TINT_BUILD_SPV_WRITER
+      break;
+    case OutputFormat::kHLSL:
+#if TINT_BUILD_HLSL_WRITER
+      writer = std::make_unique<tint::writer::hlsl::Generator>(std::move(mod));
+#endif  // TINT_BUILD_HLSL_WRITER
+      break;
+    case OutputFormat::kMSL:
+#if TINT_BUILD_MSL_WRITER
+      writer = std::make_unique<tint::writer::msl::Generator>(std::move(mod));
+#endif  // TINT_BUILD_MSL_WRITER
+      break;
+    case OutputFormat::kNone:
+      break;
+  }
+
+  if (writer) {
+    writer->Generate();
+  }
+
+  return 0;
+}
+
+}  // namespace fuzzers
+}  // namespace tint
diff --git a/fuzzers/tint_common_fuzzer.h b/fuzzers/tint_common_fuzzer.h
new file mode 100644
index 0000000000..346132d581
--- /dev/null
+++ b/fuzzers/tint_common_fuzzer.h
@@ -0,0 +1,45 @@
+// Copyright 2021 The Tint 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
+//
+//     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.
+
+#ifndef FUZZERS_TINT_COMMON_FUZZER_H_
+#define FUZZERS_TINT_COMMON_FUZZER_H_
+
+#include "include/tint/tint.h"
+
+namespace tint {
+namespace fuzzers {
+
+enum class InputFormat { kWGSL, kSpv, kNone };
+
+enum class OutputFormat { kWGSL, kSpv, kHLSL, kMSL, kNone };
+
+class CommonFuzzer {
+ public:
+  explicit CommonFuzzer(InputFormat input, OutputFormat output);
+  ~CommonFuzzer();
+
+  void SetTransformManager(transform::Manager* tm) { transform_manager_ = tm; }
+
+  int Run(const uint8_t* data, size_t size);
+
+ private:
+  InputFormat input_;
+  OutputFormat output_;
+  transform::Manager* transform_manager_;
+};
+
+}  // namespace fuzzers
+}  // namespace tint
+
+#endif  // FUZZERS_TINT_COMMON_FUZZER_H_
diff --git a/fuzzers/tint_emit_vertex_point_size_fuzzer.cc b/fuzzers/tint_emit_vertex_point_size_fuzzer.cc
new file mode 100644
index 0000000000..a2104c22eb
--- /dev/null
+++ b/fuzzers/tint_emit_vertex_point_size_fuzzer.cc
@@ -0,0 +1,32 @@
+// Copyright 2021 The Tint 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
+//
+//     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 "fuzzers/tint_common_fuzzer.h"
+
+namespace tint {
+namespace fuzzers {
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  tint::transform::Manager transform_manager;
+  transform_manager.append(
+      std::make_unique<tint::transform::EmitVertexPointSize>());
+
+  tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kSpv);
+  fuzzer.SetTransformManager(&transform_manager);
+
+  return fuzzer.Run(data, size);
+}
+
+}  // namespace fuzzers
+}  // namespace tint
diff --git a/fuzzers/tint_first_index_offset_fuzzer.cc b/fuzzers/tint_first_index_offset_fuzzer.cc
new file mode 100644
index 0000000000..eb7b74d11a
--- /dev/null
+++ b/fuzzers/tint_first_index_offset_fuzzer.cc
@@ -0,0 +1,32 @@
+// Copyright 2021 The Tint 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
+//
+//     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 "fuzzers/tint_common_fuzzer.h"
+
+namespace tint {
+namespace fuzzers {
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  tint::transform::Manager transform_manager;
+  transform_manager.append(
+      std::make_unique<tint::transform::FirstIndexOffset>(0, 0));
+
+  tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kSpv);
+  fuzzer.SetTransformManager(&transform_manager);
+
+  return fuzzer.Run(data, size);
+}
+
+}  // namespace fuzzers
+}  // namespace tint
diff --git a/fuzzers/tint_spv_reader_fuzzer.cc b/fuzzers/tint_spv_reader_fuzzer.cc
index e809e5506f..b90c09a251 100644
--- a/fuzzers/tint_spv_reader_fuzzer.cc
+++ b/fuzzers/tint_spv_reader_fuzzer.cc
@@ -14,17 +14,15 @@
 
 #include <vector>
 
-#include "src/reader/spirv/parser.h"
+#include "fuzzers/tint_common_fuzzer.h"
+
+namespace tint {
+namespace fuzzers {
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  size_t sizeInU32 = size / sizeof(uint32_t);
-  const uint32_t* u32Data = reinterpret_cast<const uint32_t*>(data);
-  std::vector<uint32_t> input(u32Data, u32Data + sizeInU32);
-
-  if (input.size() != 0) {
-    tint::reader::spirv::Parser parser(input);
-    parser.Parse();
-  }
-
-  return 0;
+  tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kSpv, OutputFormat::kNone);
+  return fuzzer.Run(data, size);
 }
+
+}  // namespace fuzzers
+}  // namespace tint
diff --git a/fuzzers/tint_spv_reader_hlsl_writer_fuzzer.cc b/fuzzers/tint_spv_reader_hlsl_writer_fuzzer.cc
new file mode 100644
index 0000000000..990002bd75
--- /dev/null
+++ b/fuzzers/tint_spv_reader_hlsl_writer_fuzzer.cc
@@ -0,0 +1,28 @@
+// Copyright 2021 The Tint 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
+//
+//     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 <vector>
+
+#include "fuzzers/tint_common_fuzzer.h"
+
+namespace tint {
+namespace fuzzers {
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kSpv, OutputFormat::kHLSL);
+  return fuzzer.Run(data, size);
+}
+
+}  // namespace fuzzers
+}  // namespace tint
diff --git a/fuzzers/tint_spv_reader_msl_writer_fuzzer.cc b/fuzzers/tint_spv_reader_msl_writer_fuzzer.cc
new file mode 100644
index 0000000000..cfff9ba38e
--- /dev/null
+++ b/fuzzers/tint_spv_reader_msl_writer_fuzzer.cc
@@ -0,0 +1,28 @@
+// Copyright 2021 The Tint 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
+//
+//     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 <vector>
+
+#include "fuzzers/tint_common_fuzzer.h"
+
+namespace tint {
+namespace fuzzers {
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kSpv, OutputFormat::kMSL);
+  return fuzzer.Run(data, size);
+}
+
+}  // namespace fuzzers
+}  // namespace tint
diff --git a/fuzzers/tint_spv_reader_spv_writer_fuzzer.cc b/fuzzers/tint_spv_reader_spv_writer_fuzzer.cc
new file mode 100644
index 0000000000..ac2d0dd421
--- /dev/null
+++ b/fuzzers/tint_spv_reader_spv_writer_fuzzer.cc
@@ -0,0 +1,28 @@
+// Copyright 2021 The Tint 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
+//
+//     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 <vector>
+
+#include "fuzzers/tint_common_fuzzer.h"
+
+namespace tint {
+namespace fuzzers {
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kSpv, OutputFormat::kSpv);
+  return fuzzer.Run(data, size);
+}
+
+}  // namespace fuzzers
+}  // namespace tint
diff --git a/fuzzers/tint_spv_reader_wgsl_writer_fuzzer.cc b/fuzzers/tint_spv_reader_wgsl_writer_fuzzer.cc
new file mode 100644
index 0000000000..30a4f1a981
--- /dev/null
+++ b/fuzzers/tint_spv_reader_wgsl_writer_fuzzer.cc
@@ -0,0 +1,28 @@
+// Copyright 2021 The Tint 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
+//
+//     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 <vector>
+
+#include "fuzzers/tint_common_fuzzer.h"
+
+namespace tint {
+namespace fuzzers {
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kSpv, OutputFormat::kWGSL);
+  return fuzzer.Run(data, size);
+}
+
+}  // namespace fuzzers
+}  // namespace tint
diff --git a/fuzzers/tint_wgsl_reader_fuzzer.cc b/fuzzers/tint_wgsl_reader_fuzzer.cc
index d1a7507429..280700eec5 100644
--- a/fuzzers/tint_wgsl_reader_fuzzer.cc
+++ b/fuzzers/tint_wgsl_reader_fuzzer.cc
@@ -14,14 +14,15 @@
 
 #include <string>
 
-#include "src/reader/wgsl/parser.h"
+#include "fuzzers/tint_common_fuzzer.h"
+
+namespace tint {
+namespace fuzzers {
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  std::string str(reinterpret_cast<const char*>(data), size);
-
-  tint::Source::File file("test.wgsl", str);
-  tint::reader::wgsl::Parser parser(&file);
-  parser.Parse();
-
-  return 0;
+  tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kNone);
+  return fuzzer.Run(data, size);
 }
+
+}  // namespace fuzzers
+}  // namespace tint
diff --git a/fuzzers/tint_wgsl_reader_hlsl_writer_fuzzer.cc b/fuzzers/tint_wgsl_reader_hlsl_writer_fuzzer.cc
new file mode 100644
index 0000000000..f10dcf5da1
--- /dev/null
+++ b/fuzzers/tint_wgsl_reader_hlsl_writer_fuzzer.cc
@@ -0,0 +1,28 @@
+// Copyright 2021 The Tint 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
+//
+//     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 <string>
+
+#include "fuzzers/tint_common_fuzzer.h"
+
+namespace tint {
+namespace fuzzers {
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kHLSL);
+  return fuzzer.Run(data, size);
+}
+
+}  // namespace fuzzers
+}  // namespace tint
diff --git a/fuzzers/tint_wgsl_reader_msl_writer_fuzzer.cc b/fuzzers/tint_wgsl_reader_msl_writer_fuzzer.cc
new file mode 100644
index 0000000000..028cab3038
--- /dev/null
+++ b/fuzzers/tint_wgsl_reader_msl_writer_fuzzer.cc
@@ -0,0 +1,28 @@
+// Copyright 2021 The Tint 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
+//
+//     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 <string>
+
+#include "fuzzers/tint_common_fuzzer.h"
+
+namespace tint {
+namespace fuzzers {
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kMSL);
+  return fuzzer.Run(data, size);
+}
+
+}  // namespace fuzzers
+}  // namespace tint
diff --git a/fuzzers/tint_wgsl_reader_spv_writer_fuzzer.cc b/fuzzers/tint_wgsl_reader_spv_writer_fuzzer.cc
new file mode 100644
index 0000000000..885f9a935a
--- /dev/null
+++ b/fuzzers/tint_wgsl_reader_spv_writer_fuzzer.cc
@@ -0,0 +1,28 @@
+// Copyright 2021 The Tint 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
+//
+//     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 <string>
+
+#include "fuzzers/tint_common_fuzzer.h"
+
+namespace tint {
+namespace fuzzers {
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kSpv);
+  return fuzzer.Run(data, size);
+}
+
+}  // namespace fuzzers
+}  // namespace tint
diff --git a/fuzzers/tint_wgsl_reader_wgsl_writer_fuzzer.cc b/fuzzers/tint_wgsl_reader_wgsl_writer_fuzzer.cc
new file mode 100644
index 0000000000..85684255c2
--- /dev/null
+++ b/fuzzers/tint_wgsl_reader_wgsl_writer_fuzzer.cc
@@ -0,0 +1,28 @@
+// Copyright 2021 The Tint 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
+//
+//     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 <string>
+
+#include "fuzzers/tint_common_fuzzer.h"
+
+namespace tint {
+namespace fuzzers {
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kWGSL);
+  return fuzzer.Run(data, size);
+}
+
+}  // namespace fuzzers
+}  // namespace tint