diff --git a/pw_log_tokenized/BUILD.gn b/pw_log_tokenized/BUILD.gn
index ce98984..a3151a5 100644
--- a/pw_log_tokenized/BUILD.gn
+++ b/pw_log_tokenized/BUILD.gn
@@ -16,7 +16,9 @@
 
 import("$dir_pw_build/target_types.gni")
 import("$dir_pw_docgen/docs.gni")
+import("$dir_pw_log/backend.gni")
 import("$dir_pw_tokenizer/backend.gni")
+import("$dir_pw_unit_test/facade_test.gni")
 import("$dir_pw_unit_test/test.gni")
 
 config("public_includes") {
@@ -74,18 +76,22 @@
 }
 
 pw_test_group("tests") {
-  tests = [ ":test" ]
+  tests = [ ":log_tokenized_test" ]
 }
 
-pw_test("test") {
+pw_facade_test("log_tokenized_test") {
+  build_args = {
+    # The test provides pw_tokenizer_GLOBAL_HANDLER_WITH_PAYLOAD_BACKEND in the
+    # .cc file, but we can't depend on the test as it creates a circular
+    # dependency.
+    pw_tokenizer_GLOBAL_HANDLER_WITH_PAYLOAD_BACKEND = "$dir_pw_build:empty"
+  }
   sources = [ "test.cc" ]
   deps = [
     ":log_backend",
     ":pw_log_tokenized",
   ]
-
-  # TODO(hepler): Switch this to a facade test when available.
-  enable_if = pw_tokenizer_GLOBAL_HANDLER_WITH_PAYLOAD_BACKEND == ""
+  enable_if = pw_log_BACKEND == "$dir_pw_log_tokenized:log_backend"
 }
 
 pw_doc_group("docs") {
diff --git a/pw_toolchain/generate_toolchain.gni b/pw_toolchain/generate_toolchain.gni
index 712369f..af3f5e2 100644
--- a/pw_toolchain/generate_toolchain.gni
+++ b/pw_toolchain/generate_toolchain.gni
@@ -18,7 +18,7 @@
 
 declare_args() {
   # Scope defining the current toolchain. Contains all of the arguments required
-  # by the generate_toolchain template.
+  # by the generate_toolchain template. This should NOT be manually modified.
   pw_toolchain_SCOPE = {
   }
 
@@ -42,8 +42,14 @@
 #     all object files when resolving symbols.
 #   link_group: (optional) Boolean indicating if the linker should use
 #     a group to resolve circular dependencies between artifacts.
-#   defaults: (required) A scope setting defaults to apply to GN
-#     targets in this toolchain, as described in pw_vars_default.gni
+#   generate_from: (optional) The full target name of the toolchain that can
+#     trigger this toolchain to be generated. GN only allows one toolchain to
+#     be generated at a given target path, so if multiple toolchains parse the
+#     same generate_toolchain target only one should declare a toolchain. This
+#     is primarily to allow generating sub-toolchains. Defaults to
+#     default_toolchain.
+#   defaults: (required) A scope setting GN build arg values to apply to GN
+#     targets in this toolchain. These take precedence over args.gni settings.
 #
 # The defaults scope should contain values for builtin GN arguments:
 #   current_cpu: The CPU of the toolchain.
@@ -51,14 +57,24 @@
 #   current_os: The OS of the toolchain. Defaults to "".
 #     Well known values include "win", "mac", "linux", "android", and "ios".
 #
+# TODO(pwbug/333): This should be renamed to pw_generate_toolchain.
 template("generate_toolchain") {
   assert(defined(invoker.defaults), "toolchain is missing 'defaults'")
 
-  # In multi-toolchain builds from the top level, we run into issues where
-  # toolchains defined with this template are re-generated each time. To avoid
-  # collisions, the actual toolchain is only generated for the default (dummy)
-  # toolchain, and an unused target is created otherwise.
-  if (current_toolchain == default_toolchain) {
+  # On the default toolchain invocation, you typically need to generate all
+  # toolchains you encounter. For sub-toolchains, they must be generated from
+  # the context of their parent.
+  if (defined(invoker.generate_from)) {
+    _generate_toolchain =
+        get_label_info(invoker.generate_from, "label_no_toolchain") ==
+        current_toolchain
+  } else {
+    _generate_toolchain = default_toolchain == current_toolchain
+  }
+
+  if (_generate_toolchain) {
+    # TODO(amontanez): This should be renamed to build_args as "defaults" isn't
+    # sufficiently descriptive.
     invoker_toolchain_args = invoker.defaults
 
     # These values should always be set as they influence toolchain
@@ -74,6 +90,9 @@
     toolchain_os = invoker_toolchain_args.current_os
 
     toolchain(target_name) {
+      # Uncomment this line to see which toolchains generate other toolchains.
+      # print("Generating toolchain: ${target_name} by ${current_toolchain}")
+
       assert(defined(invoker.cc), "toolchain is missing 'cc'")
       tool("asm") {
         if (pw_command_launcher != "") {
@@ -329,6 +348,7 @@
         }
         pw_toolchain_SCOPE = {
           forward_variables_from(invoker, "*")
+          name = target_name
         }
         forward_variables_from(invoker_toolchain_args, "*")
       }
diff --git a/pw_toolchain/subtoolchain.gni b/pw_toolchain/subtoolchain.gni
new file mode 100644
index 0000000..f5ba3dc
--- /dev/null
+++ b/pw_toolchain/subtoolchain.gni
@@ -0,0 +1,48 @@
+# Copyright 2020 The Pigweed 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.
+
+import("//build_overrides/pigweed.gni")
+
+import("$dir_pw_toolchain/generate_toolchain.gni")
+
+# Generates a toolchain using the currently active toolchain as a foundation.
+# WARNING: Only works with toolchains generated by Pigweed's generate_toolchain.
+# WARNING: This can quickly create an explosion of toolchains and compile times.
+#   Use sparingly!
+#
+# Args:
+#   build_args: (required) A scope setting GN build arg values to apply to GN
+#     targets in this toolchain. These take precedence over args.gni settings,
+#     and any build_args set by the currently active toolchain.
+#   (other): You can optionally override all other generate_toolchain args. See
+#     that template's documentation for more information.
+template("pw_generate_subtoolchain") {
+  assert(defined(invoker.build_args), "Sub-toolchain is missing 'build_args'")
+  _original_scope = pw_toolchain_SCOPE
+  assert(defined(_original_scope.name),
+         "Sub-toolchain must be generated from a Pigweed toolchain")
+
+  generate_toolchain(target_name) {
+    forward_variables_from(_original_scope, "*", [ "defaults" ])
+    forward_variables_from(invoker, "*", [ "build_args" ])
+
+    # Subtoolchains must always be generated from the toolchain that parses
+    # them rather than relying on the default_toolchain.
+    generate_from = current_toolchain
+    defaults = {
+      forward_variables_from(_original_scope.defaults, "*")
+      forward_variables_from(invoker.build_args, "*")
+    }
+  }
+}
diff --git a/pw_unit_test/docs.rst b/pw_unit_test/docs.rst
index 12f5ca5..27fda58 100644
--- a/pw_unit_test/docs.rst
+++ b/pw_unit_test/docs.rst
@@ -212,6 +212,23 @@
     # ...
   }
 
+pw_facade_test template
+-----------------------
+Pigweed facade test templates allow individual unit tests to build under the
+current device target configuration while overriding specific build arguments.
+This allows these tests to replace a facade's backend for the purpose of testing
+the facade layer.
+
+.. warning::
+   Facade tests are costly because each facade test will trigger a re-build of
+   every dependency of the test. While this sounds excessive, it's the only
+   technically correct way to handle this type of test.
+
+.. warning::
+   Some facade test configurations may not be compatible with your target. Be
+   careful when running a facade test on a system that heavily depends on the
+   facade being tested.
+
 RPC service
 ===========
 ``pw_unit_test`` provides an RPC service which runs unit tests on demand and
diff --git a/pw_unit_test/facade_test.gni b/pw_unit_test/facade_test.gni
new file mode 100644
index 0000000..4912888
--- /dev/null
+++ b/pw_unit_test/facade_test.gni
@@ -0,0 +1,105 @@
+# Copyright 2021 The Pigweed 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.
+
+import("//build_overrides/pigweed.gni")
+
+import("$dir_pw_toolchain/generate_toolchain.gni")
+import("$dir_pw_toolchain/subtoolchain.gni")
+import("$dir_pw_unit_test/test.gni")
+
+declare_args() {
+  # Pigweed uses this internally to manage toolchain generation for facade
+  # tests. This should NEVER be set manually, or depended on as stable API.
+  pw_unit_test_FACADE_TEST_NAME = ""
+}
+
+# Create a facade test. This allows you to, for a single unit test, replace
+# backends for the purpose of testing logic in a facade. To test a single
+# facade, multiple backends may need to be replaced (e.g. to test logging, you
+# can't be using the logging test runner).
+#
+# Note: pw_facade_test names MUST be globally unique, as they all are enumerated
+# to GN's output directory.
+# (e.g. `out/stm32f429i_disc1_size_optimized.tokenizer_facade_test`)
+#
+# WARNING: Facade tests can be very costly, as ALL the test/target dependencies
+#   will be rebuilt in a completely new toolchain context. This may seem
+#   wasteful, but is the only technically correct solution.
+#
+# Args:
+#   build_args: (required) Toolchain build arguments to override in the
+#     generated subtoolchain.
+#   toolchain_suffix: (optional) The suffix to use when generating a
+#     subtoolchain for the currently active toolchain. This must be globally
+#     unique as two tests with the same toolchain_suffix will generate the same
+#     toolchain name, which is illegal.
+template("pw_facade_test") {
+  assert(
+      defined(invoker.build_args),
+      "A facade test with no `defaults` is just a more expensive pw_unit_test!")
+  assert(
+      target_name != "test",
+      "This is a dangerous name, facade tests must have globally unique names!")
+
+  # Only try to generate a facade test for toolchains created by
+  # generate_toolchain. Checking if pw_toolchain_SCOPE has the "name" member
+  # is a reliable way to do this since it's only ever set by generate_toolchain.
+  if (defined(pw_toolchain_SCOPE.name)) {
+    if (defined(invoker.toolchain_suffix)) {
+      _subtoolchain_suffix = invoker.toolchain_suffix
+    } else {
+      _subtoolchain_suffix =
+          get_label_info(":$target_name", "label_no_toolchain")
+      _subtoolchain_suffix = string_replace(_subtoolchain_suffix, "//", "")
+      _subtoolchain_suffix = string_replace(_subtoolchain_suffix, "/", "-")
+      _subtoolchain_suffix = string_replace(_subtoolchain_suffix, ":", "--")
+    }
+
+    # Generate a subtoolchain for this test unless we're already in the
+    # context of a subtoolchain that was generated for this test.
+    if (pw_unit_test_FACADE_TEST_NAME != _subtoolchain_suffix) {
+      # If this branch is hit, we're still in the context of the parent
+      # toolchain, and we should generate the subtoolchain for this test.
+      _current_toolchain_name = get_label_info(current_toolchain, "name")
+      _subtoolchain_name = "${_current_toolchain_name}.${_subtoolchain_suffix}"
+      pw_generate_subtoolchain(_subtoolchain_name) {
+        build_args = {
+          pw_unit_test_FACADE_TEST_NAME = _subtoolchain_suffix
+          forward_variables_from(invoker.build_args, "*")
+        }
+      }
+      not_needed(invoker, "*")
+
+      # This target acts as a somewhat strange passthrough. In this toolchain,
+      # it refers to a test group that depends on a test of the same name in the
+      # context of another toolchain. In the subtoolchain, this same target name
+      # refers to a concrete test. It's like Inception.
+      pw_test_group(target_name) {
+        tests = [ ":$target_name(:$_subtoolchain_name)" ]
+      }
+    } else {
+      # In this branch, we instantiate the actual pw_test target that can be
+      # run.
+      pw_test(target_name) {
+        forward_variables_from(invoker, "*", [ "build_args" ])
+      }
+    }
+  } else {
+    # Dummy target for non-pigweed toolchains.
+    not_needed(invoker, "*")
+    pw_test_group(target_name) {
+      enable_if = false
+    }
+  }
+}