diff --git a/build/gen.py b/build/gen.py
index ae9c40d..5fd5783 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -576,6 +576,7 @@
         'src/gn/bundle_data.cc',
         'src/gn/bundle_data_target_generator.cc',
         'src/gn/bundle_file_rule.cc',
+        'src/gn/builtin_tool.cc',
         'src/gn/c_include_iterator.cc',
         'src/gn/c_substitution_type.cc',
         'src/gn/c_tool.cc',
diff --git a/src/gn/build_settings.h b/src/gn/build_settings.h
index 9a6c514..6c925e9 100644
--- a/src/gn/build_settings.h
+++ b/src/gn/build_settings.h
@@ -61,6 +61,15 @@
   }
   void set_ninja_required_version(Version v) { ninja_required_version_ = v; }
 
+  // The 'no_stamp_files' boolean flag can be set to generate Ninja files
+  // that use phony rules instead of stamp files in most cases. This reduces
+  // the size of the generated Ninja build plans, but requires Ninja 1.11
+  // or greater to properly process them.
+  bool no_stamp_files() const { return no_stamp_files_; }
+  void set_no_stamp_files(bool no_stamp_files) {
+    no_stamp_files_ = no_stamp_files;
+  }
+
   const SourceFile& build_config_file() const { return build_config_file_; }
   void set_build_config_file(const SourceFile& f) { build_config_file_ = f; }
 
@@ -134,6 +143,7 @@
 
   // See 40045b9 for the reason behind using 1.7.2 as the default version.
   Version ninja_required_version_{1, 7, 2};
+  bool no_stamp_files_ = false;
 
   SourceFile build_config_file_;
   SourceFile arg_file_template_path_;
diff --git a/src/gn/builtin_tool.cc b/src/gn/builtin_tool.cc
new file mode 100644
index 0000000..e9f17ef
--- /dev/null
+++ b/src/gn/builtin_tool.cc
@@ -0,0 +1,47 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "gn/builtin_tool.h"
+#include "base/logging.h"
+#include "gn/target.h"
+
+// static
+const char BuiltinTool::kBuiltinToolPhony[] = "phony";
+
+BuiltinTool::BuiltinTool(const char* n) : Tool(n) {
+  CHECK(ValidateName(n));
+  // Unlike regular tools, which are read from a file,
+  // builtin-tools are always ready to go and do not need
+  // phased construction.
+  SetToolComplete();
+}
+
+BuiltinTool::~BuiltinTool() = default;
+
+BuiltinTool* BuiltinTool::AsBuiltin() {
+  return this;
+}
+const BuiltinTool* BuiltinTool::AsBuiltin() const {
+  return this;
+}
+
+bool BuiltinTool::ValidateName(const char* name) const {
+  return name == kBuiltinToolPhony;
+}
+
+void BuiltinTool::SetComplete() {
+  // Already performed in constructor
+}
+
+bool BuiltinTool::InitTool(Scope* scope, Toolchain* toolchain, Err* err) {
+  // Initialize default vars.
+  return Tool::InitTool(scope, toolchain, err);
+}
+
+bool BuiltinTool::ValidateSubstitution(const Substitution* sub_type) const {
+  if (name_ == kBuiltinToolPhony)
+    return IsValidToolSubstitution(sub_type);
+  NOTREACHED();
+  return false;
+}
diff --git a/src/gn/builtin_tool.h b/src/gn/builtin_tool.h
new file mode 100644
index 0000000..0aff49d
--- /dev/null
+++ b/src/gn/builtin_tool.h
@@ -0,0 +1,41 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef TOOLS_GN_BUILTIN_TOOL_H_
+#define TOOLS_GN_BUILTIN_TOOL_H_
+
+#include <string>
+
+#include "gn/substitution_list.h"
+#include "gn/substitution_pattern.h"
+#include "gn/tool.h"
+
+// A built-in tool that is always available regardless of toolchain. So far, the
+// only example of this is the phony rule that ninja provides.
+class BuiltinTool : public Tool {
+ public:
+  // Builtin tools
+  static const char kBuiltinToolPhony[];
+
+  // Explicit constructor. Note that |name| must be one of the kBuiltinToolXXX
+  // constant pointers defined above.
+  explicit BuiltinTool(const char* name);
+  ~BuiltinTool();
+
+  // Manual RTTI and required functions ---------------------------------------
+
+  bool InitTool(Scope* block_scope, Toolchain* toolchain, Err* err);
+  bool ValidateName(const char* name) const override;
+  void SetComplete() override;
+  bool ValidateSubstitution(const Substitution* sub_type) const override;
+
+  BuiltinTool* AsBuiltin() override;
+  const BuiltinTool* AsBuiltin() const override;
+
+ private:
+  BuiltinTool(const BuiltinTool&) = delete;
+  BuiltinTool& operator=(const BuiltinTool&) = delete;
+};
+
+#endif  // TOOLS_GN_BUILTIN_TOOL_H_
diff --git a/src/gn/filesystem_utils.cc b/src/gn/filesystem_utils.cc
index 6471378..6de3fbd 100644
--- a/src/gn/filesystem_utils.cc
+++ b/src/gn/filesystem_utils.cc
@@ -1006,6 +1006,8 @@
     result.value().append("gen/");
   else if (type == BuildDirType::OBJ)
     result.value().append("obj/");
+  else if (type == BuildDirType::PHONY)
+    result.value().append("phony/");
   return result;
 }
 
diff --git a/src/gn/filesystem_utils.h b/src/gn/filesystem_utils.h
index 2c826b5..590f9e3 100644
--- a/src/gn/filesystem_utils.h
+++ b/src/gn/filesystem_utils.h
@@ -222,6 +222,12 @@
 
   // Output file directory.
   OBJ,
+
+  // Phony file directory. As the name implies, this is not a real file
+  // directory, but a path that is used for the declaration of phony targets.
+  // This is done to avoid duplicate target names between real files and phony
+  // aliases that point to them.
+  PHONY,
 };
 
 // In different contexts, different information is known about the toolchain in
diff --git a/src/gn/json_project_writer.cc b/src/gn/json_project_writer.cc
index a54e254..ba23749 100644
--- a/src/gn/json_project_writer.cc
+++ b/src/gn/json_project_writer.cc
@@ -455,6 +455,9 @@
       base::Value toolchain{base::Value::Type::DICTIONARY};
       const auto& tools = tool_chain_kv.second->tools();
       for (const auto& tool_kv : tools) {
+        // Do not list builtin tools
+        if (tool_kv.second->AsBuiltin())
+          continue;
         base::Value tool_info{base::Value::Type::DICTIONARY};
         auto setIfNotEmptry = [&](const auto& key, const auto& value) {
           if (value.size())
diff --git a/src/gn/ninja_toolchain_writer.cc b/src/gn/ninja_toolchain_writer.cc
index 7be7719..2314bae 100644
--- a/src/gn/ninja_toolchain_writer.cc
+++ b/src/gn/ninja_toolchain_writer.cc
@@ -9,6 +9,7 @@
 #include "base/files/file_util.h"
 #include "base/strings/stringize_macros.h"
 #include "gn/build_settings.h"
+#include "gn/builtin_tool.h"
 #include "gn/c_tool.h"
 #include "gn/filesystem_utils.h"
 #include "gn/general_tool.h"
@@ -43,8 +44,10 @@
   std::string rule_prefix = GetNinjaRulePrefixForToolchain(settings_);
 
   for (const auto& tool : toolchain_->tools()) {
-    if (tool.second->name() == GeneralTool::kGeneralToolAction)
+    if (tool.second->name() == GeneralTool::kGeneralToolAction ||
+        tool.second->AsBuiltin()) {
       continue;
+    }
     WriteToolRule(tool.second.get(), rule_prefix);
   }
   out_ << std::endl;
diff --git a/src/gn/setup.cc b/src/gn/setup.cc
index b6fdee2..9dba72e 100644
--- a/src/gn/setup.cc
+++ b/src/gn/setup.cc
@@ -1024,5 +1024,16 @@
     build_settings_.set_arg_file_template_path(path);
   }
 
+  // No stamp files.
+  const Value* no_stamp_files_value =
+      dotfile_scope_.GetValue("no_stamp_files", true);
+  if (no_stamp_files_value) {
+    if (!no_stamp_files_value->VerifyTypeIs(Value::BOOLEAN, err)) {
+      return false;
+    }
+    build_settings_.set_no_stamp_files(no_stamp_files_value->boolean_value());
+    CHECK(!build_settings_.no_stamp_files()) << "no_stamp_files does not work yet!";
+  }
+
   return true;
 }
diff --git a/src/gn/tool.cc b/src/gn/tool.cc
index bf3aba6..684dc3e 100644
--- a/src/gn/tool.cc
+++ b/src/gn/tool.cc
@@ -4,6 +4,7 @@
 
 #include "gn/tool.h"
 
+#include "gn/builtin_tool.h"
 #include "gn/c_tool.h"
 #include "gn/general_tool.h"
 #include "gn/rust_tool.h"
@@ -52,6 +53,13 @@
   return nullptr;
 }
 
+BuiltinTool* Tool::AsBuiltin() {
+  return nullptr;
+}
+const BuiltinTool* Tool::AsBuiltin() const {
+  return nullptr;
+}
+
 bool Tool::IsPatternInOutputList(const SubstitutionList& output_list,
                                  const SubstitutionPattern& pattern) const {
   for (const auto& cur : output_list.list()) {
@@ -342,7 +350,7 @@
 
 // static
 const char* Tool::GetToolTypeForTargetFinalOutput(const Target* target) {
-  // The contents of this list might be surprising (i.e. stamp tool for copy
+  // The contents of this list might be surprising (i.e. phony tool for copy
   // rules). See the header for why.
   // TODO(crbug.com/gn/39): Don't emit stamp files for single-output targets.
   if (target->source_types_used().RustSourceUsed()) {
@@ -366,8 +374,6 @@
     }
   }
   switch (target->output_type()) {
-    case Target::GROUP:
-      return GeneralTool::kGeneralToolStamp;
     case Target::EXECUTABLE:
       return CTool::kCToolLink;
     case Target::SHARED_LIBRARY:
@@ -376,15 +382,19 @@
       return CTool::kCToolSolinkModule;
     case Target::STATIC_LIBRARY:
       return CTool::kCToolAlink;
-    case Target::SOURCE_SET:
-      return GeneralTool::kGeneralToolStamp;
     case Target::ACTION:
     case Target::ACTION_FOREACH:
     case Target::BUNDLE_DATA:
-    case Target::CREATE_BUNDLE:
     case Target::COPY_FILES:
+    case Target::CREATE_BUNDLE:
     case Target::GENERATED_FILE:
-      return GeneralTool::kGeneralToolStamp;
+    case Target::GROUP:
+    case Target::SOURCE_SET:
+      if (target->settings()->build_settings()->no_stamp_files()) {
+        return BuiltinTool::kBuiltinToolPhony;
+      } else {
+        return GeneralTool::kGeneralToolStamp;
+      }
     default:
       NOTREACHED();
       return kToolNone;
diff --git a/src/gn/tool.h b/src/gn/tool.h
index 1e01af7..b95c64b 100644
--- a/src/gn/tool.h
+++ b/src/gn/tool.h
@@ -23,6 +23,7 @@
 class CTool;
 class GeneralTool;
 class RustTool;
+class BuiltinTool;
 
 // To add a new Tool category, create a subclass implementing SetComplete()
 // Add a new category to ToolCategories
@@ -62,6 +63,8 @@
   virtual const GeneralTool* AsGeneral() const;
   virtual RustTool* AsRust();
   virtual const RustTool* AsRust() const;
+  virtual BuiltinTool* AsBuiltin();
+  virtual const BuiltinTool* AsBuiltin() const;
 
   // Basic information ---------------------------------------------------------
 
@@ -233,6 +236,7 @@
                                           Err* err);
 
   static const char* GetToolTypeForSourceType(SourceFile::Type type);
+
   static const char* GetToolTypeForTargetFinalOutput(const Target* target);
 
  protected:
diff --git a/src/gn/toolchain.cc b/src/gn/toolchain.cc
index bfad81d..a656184 100644
--- a/src/gn/toolchain.cc
+++ b/src/gn/toolchain.cc
@@ -9,13 +9,19 @@
 #include <utility>
 
 #include "base/logging.h"
+#include "gn/builtin_tool.h"
+#include "gn/settings.h"
 #include "gn/target.h"
 #include "gn/value.h"
 
 Toolchain::Toolchain(const Settings* settings,
                      const Label& label,
                      const SourceFileSet& build_dependency_files)
-    : Item(settings, label, build_dependency_files) {}
+    : Item(settings, label, build_dependency_files) {
+  // Ensure "phony" tool is part of all toolchains by default.
+  const char* phony_name = BuiltinTool::kBuiltinToolPhony;
+  tools_.emplace(phony_name, std::make_unique<BuiltinTool>(phony_name));
+}
 
 Toolchain::~Toolchain() = default;
 
@@ -87,6 +93,20 @@
   return nullptr;
 }
 
+BuiltinTool* Toolchain::GetToolAsBuiltin(const char* name) {
+  if (Tool* tool = GetTool(name)) {
+    return tool->AsBuiltin();
+  }
+  return nullptr;
+}
+
+const BuiltinTool* Toolchain::GetToolAsBuiltin(const char* name) const {
+  if (const Tool* tool = GetTool(name)) {
+    return tool->AsBuiltin();
+  }
+  return nullptr;
+}
+
 void Toolchain::SetTool(std::unique_ptr<Tool> t) {
   DCHECK(t->name() != Tool::kToolNone);
   DCHECK(tools_.find(t->name()) == tools_.end());
@@ -120,6 +140,11 @@
   return GetToolAsRust(Tool::GetToolTypeForSourceType(type));
 }
 
+const BuiltinTool* Toolchain::GetToolForSourceTypeAsBuiltin(
+    SourceFile::Type type) const {
+  return GetToolAsBuiltin(Tool::GetToolTypeForSourceType(type));
+}
+
 const Tool* Toolchain::GetToolForTargetFinalOutput(const Target* target) const {
   return GetTool(Tool::GetToolTypeForTargetFinalOutput(target));
 }
@@ -138,3 +163,8 @@
     const Target* target) const {
   return GetToolAsRust(Tool::GetToolTypeForTargetFinalOutput(target));
 }
+
+const BuiltinTool* Toolchain::GetToolForTargetFinalOutputAsBuiltin(
+    const Target* target) const {
+  return GetToolAsBuiltin(Tool::GetToolTypeForTargetFinalOutput(target));
+}
diff --git a/src/gn/toolchain.h b/src/gn/toolchain.h
index eb5a60c..270fada 100644
--- a/src/gn/toolchain.h
+++ b/src/gn/toolchain.h
@@ -16,6 +16,8 @@
 #include "gn/tool.h"
 #include "gn/value.h"
 
+class BuiltinTool;
+
 // Holds information on a specific toolchain. This data is filled in when we
 // encounter a toolchain definition.
 //
@@ -62,6 +64,8 @@
   const CTool* GetToolAsC(const char* name) const;
   RustTool* GetToolAsRust(const char* name);
   const RustTool* GetToolAsRust(const char* name) const;
+  BuiltinTool* GetToolAsBuiltin(const char* name);
+  const BuiltinTool* GetToolAsBuiltin(const char* name) const;
 
   // Set a tool. When all tools are configured, you should call
   // ToolchainSetupComplete().
@@ -93,6 +97,7 @@
   const CTool* GetToolForSourceTypeAsC(SourceFile::Type type) const;
   const GeneralTool* GetToolForSourceTypeAsGeneral(SourceFile::Type type) const;
   const RustTool* GetToolForSourceTypeAsRust(SourceFile::Type type) const;
+  const BuiltinTool* GetToolForSourceTypeAsBuiltin(SourceFile::Type type) const;
 
   // Returns the tool that produces the final output for the given target type.
   // This isn't necessarily the tool you would expect. For copy target, this
@@ -103,6 +108,8 @@
   const GeneralTool* GetToolForTargetFinalOutputAsGeneral(
       const Target* target) const;
   const RustTool* GetToolForTargetFinalOutputAsRust(const Target* target) const;
+  const BuiltinTool* GetToolForTargetFinalOutputAsBuiltin(
+      const Target* target) const;
 
   const SubstitutionBits& substitution_bits() const {
     DCHECK(setup_complete_);