diff --git a/docs/reference.md b/docs/reference.md
index 7e848c7..a2231e6 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -165,6 +165,7 @@
     *   [target_xcode_platform: [string] The desired platform for the build.](#var_target_xcode_platform)
     *   [testonly: [boolean] Declares a target must only be used for testing.](#var_testonly)
     *   [transparent: [bool] True if the bundle is transparent.](#var_transparent)
+    *   [validations: [label list] Validation dependencies.](#var_validations)
     *   [visibility: [label list] A list of labels that can depend on a target.](#var_visibility)
     *   [walk_keys: [string list] Key(s) for managing the metadata collection walk.](#var_walk_keys)
     *   [weak_frameworks: [name list] Name of frameworks that must be weak linked.](#var_weak_frameworks)
@@ -6966,6 +6967,31 @@
   depends on it (unless the "bundle_data" target sets "product_type" to the
   same value as the "create_bundle" target).
 ```
+### <a name="var_validations"></a>**validations**: Validation dependencies.&nbsp;[Back to Top](#gn-reference)
+
+```
+  A list of target labels.
+
+  "Validations" are a list of targets that should be built if the current
+  target is built, but which do not effect the result of the current target.
+  This is used to declare things like static analysis, style checking, or
+  other checks that should run in parallel with the build.
+```
+
+#### **Example**
+
+```
+  executable("my_program") {
+    sources = [ "my_program.cc" ]
+    validations = [ ":my_program_style_check" ]
+  }
+
+  action("my_program_style_check") {
+    script = "//tools/style_checker.py"
+    sources = [ "my_program.cc" ]
+    outputs = [ "$target_gen_dir/my_program_style_check.stamp" ]
+  }
+```
 ### <a name="var_visibility"></a>**visibility**: A list of labels that can depend on a target.&nbsp;[Back to Top](#gn-reference)
 
 ```
diff --git a/src/gn/builder.cc b/src/gn/builder.cc
index 3710886..84eff84 100644
--- a/src/gn/builder.cc
+++ b/src/gn/builder.cc
@@ -89,6 +89,19 @@
 
   record->set_item(std::move(item));
 
+  // Notify anyone waiting on this item's definition.
+  const BuilderRecordSet& waiting_deps = record->waiting_on_definition();
+  for (auto it = waiting_deps.begin(); it.valid(); ++it) {
+    BuilderRecord* waiting = *it;
+    if (waiting->OnDefinedDep(record)) {
+      if (!ResolveItem(waiting, &err)) {
+        g_scheduler->FailWithError(err);
+        return;
+      }
+    }
+  }
+  record->waiting_on_definition().clear();
+
   // Do target-specific dependency setup. This will also schedule dependency
   // loads for targets that are required.
   switch (type) {
@@ -257,7 +270,9 @@
       !AddDeps(record, target->all_dependent_configs(), err) ||
       !AddDeps(record, target->public_configs(), err) ||
       !AddGenDeps(record, target->gen_deps(), err) ||
-      !AddPoolDep(record, target, err) || !AddToolchainDep(record, target, err))
+      !AddPoolDep(record, target, err) ||
+      !AddToolchainDep(record, target, err) ||
+      !AddValidationDeps(record, target->validations(), err))
     return false;
 
   // All targets in the default toolchain get generated by default. We also
@@ -464,6 +479,19 @@
   return true;
 }
 
+bool Builder::AddValidationDeps(BuilderRecord* record,
+                                const LabelTargetVector& targets,
+                                Err* err) {
+  for (const auto& target : targets) {
+    BuilderRecord* dep_record = GetOrCreateRecordOfType(
+        target.label, target.origin, BuilderRecord::ITEM_TARGET, err);
+    if (!dep_record)
+      return false;
+    record->AddValidationDep(dep_record);
+  }
+  return true;
+}
+
 void Builder::RecursiveSetShouldGenerate(BuilderRecord* record, bool force) {
   if (!record->should_generate()) {
     // This function can encounter cycles because gen_deps aren't a DAG. Setting
@@ -501,6 +529,7 @@
     if (!ResolveDeps(&target->public_deps(), err) ||
         !ResolveDeps(&target->private_deps(), err) ||
         !ResolveDeps(&target->data_deps(), err) ||
+        !ResolveDeps(&target->validations(), err) ||
         !ResolveConfigs(&target->configs(), err) ||
         !ResolveConfigs(&target->all_dependent_configs(), err) ||
         !ResolveConfigs(&target->public_configs(), err) ||
diff --git a/src/gn/builder.h b/src/gn/builder.h
index 6776363..6578a89 100644
--- a/src/gn/builder.h
+++ b/src/gn/builder.h
@@ -103,6 +103,9 @@
                   Err* err);
   bool AddPoolDep(BuilderRecord* record, const Target* target, Err* err);
   bool AddToolchainDep(BuilderRecord* record, const Target* target, Err* err);
+  bool AddValidationDeps(BuilderRecord* record,
+                         const LabelTargetVector& targets,
+                         Err* err);
 
   // Given a target, sets the "should generate" bit and pushes it through the
   // dependency tree. Any time the bit it set, we ensure that the given item is
diff --git a/src/gn/builder_record.cc b/src/gn/builder_record.cc
index d1d0c53..f5af711 100644
--- a/src/gn/builder_record.cc
+++ b/src/gn/builder_record.cc
@@ -62,12 +62,32 @@
   return ITEM_UNKNOWN;
 }
 
+void BuilderRecord::AddDep(BuilderRecord* record) {
+  if (all_deps_.add(record) && !record->resolved()) {
+    unresolved_count_ += 1;
+    record->waiting_on_resolution_.add(this);
+  }
+}
+
 void BuilderRecord::AddGenDep(BuilderRecord* record) {
   // Records don't have to wait on resolution of their gen deps, since all they
   // need to do is propagate should_generate to them.
   all_deps_.insert(record);
 }
 
+void BuilderRecord::AddValidationDep(BuilderRecord* record) {
+  if (all_deps_.add(record) && !record->item()) {
+    unresolved_count_ += 1;
+    record->waiting_on_definition_.add(this);
+  }
+}
+
+bool BuilderRecord::OnDefinedDep(const BuilderRecord* dep) {
+  DCHECK(all_deps_.contains(const_cast<BuilderRecord*>(dep)));
+  DCHECK(unresolved_count_ > 0);
+  return --unresolved_count_ == 0;
+}
+
 bool BuilderRecord::OnResolvedDep(const BuilderRecord* dep) {
   DCHECK(all_deps_.contains(const_cast<BuilderRecord*>(dep)));
   DCHECK(unresolved_count_ > 0);
@@ -79,16 +99,11 @@
   std::vector<const BuilderRecord*> result;
   for (auto it = all_deps_.begin(); it.valid(); ++it) {
     BuilderRecord* dep = *it;
-    if (dep->waiting_on_resolution_.contains(const_cast<BuilderRecord*>(this)))
+    if (dep->waiting_on_resolution_.contains(
+            const_cast<BuilderRecord*>(this)) ||
+        dep->waiting_on_definition_.contains(const_cast<BuilderRecord*>(this)))
       result.push_back(dep);
   }
   std::sort(result.begin(), result.end(), LabelCompare);
   return result;
 }
-
-void BuilderRecord::AddDep(BuilderRecord* record) {
-  if (all_deps_.add(record) && !record->resolved()) {
-    unresolved_count_ += 1;
-    record->waiting_on_resolution_.add(this);
-  }
-}
diff --git a/src/gn/builder_record.h b/src/gn/builder_record.h
index c4dc867..06ff6c3 100644
--- a/src/gn/builder_record.h
+++ b/src/gn/builder_record.h
@@ -82,20 +82,34 @@
   // as a list sorted by label.
   std::vector<const BuilderRecord*> GetSortedUnresolvedDeps() const;
 
-  // Call this method to notify the record that its dependency |dep| was
-  // just resolved. This returns true to indicate that the current record
-  // should now be resolved.
-  bool OnResolvedDep(const BuilderRecord* dep);
+  // Records that are waiting on this one to be defined. This is used for
+  // "validations" dependencies which don't require the target to be fully
+  // resolved, only defined.
+  BuilderRecordSet& waiting_on_definition() { return waiting_on_definition_; }
+  const BuilderRecordSet& waiting_on_definition() const {
+    return waiting_on_definition_;
+  }
 
   // Records that are waiting on this one to be resolved. This is the other
-  // end of the "unresolved deps" arrow.
+  // end of the "unresolved deps" arrow for standard dependencies.
   BuilderRecordSet& waiting_on_resolution() { return waiting_on_resolution_; }
   const BuilderRecordSet& waiting_on_resolution() const {
     return waiting_on_resolution_;
   }
 
-  void AddGenDep(BuilderRecord* record);
   void AddDep(BuilderRecord* record);
+  void AddGenDep(BuilderRecord* record);
+  void AddValidationDep(BuilderRecord* record);
+
+  // Call this method to notify the record that its dependency |dep| was
+  // just defined. This returns true to indicate that the current record
+  // should now be resolved.
+  bool OnDefinedDep(const BuilderRecord* dep);
+
+  // Call this method to notify the record that its dependency |dep| was
+  // just resolved. This returns true to indicate that the current record
+  // should now be resolved.
+  bool OnResolvedDep(const BuilderRecord* dep);
 
   // Comparator function used to sort records from their label.
   static bool LabelCompare(const BuilderRecord* a, const BuilderRecord* b) {
@@ -113,6 +127,7 @@
   size_t unresolved_count_ = 0;
   BuilderRecordSet all_deps_;
   BuilderRecordSet waiting_on_resolution_;
+  BuilderRecordSet waiting_on_definition_;
 
   BuilderRecord(const BuilderRecord&) = delete;
   BuilderRecord& operator=(const BuilderRecord&) = delete;
diff --git a/src/gn/builder_unittest.cc b/src/gn/builder_unittest.cc
index accd714..da497c7 100644
--- a/src/gn/builder_unittest.cc
+++ b/src/gn/builder_unittest.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include <algorithm>
+#include <memory>
 
 #include "gn/builder.h"
 #include "gn/config.h"
@@ -375,4 +376,59 @@
   EXPECT_TRUE(loader_->HasLoadedOne(SourceFile("//b/BUILD.gn")));
 }
 
+// Tests that "validations" dependencies behave correctly:
+// 1. They trigger the loading of the validated target's build file (simulating
+// cross-directory deps).
+// 2. The validator waits for the validation target to be DEFINED, not RESOLVED.
+// 3. This allows cycles (A validates B, B depends on A) to resolve without
+// error.
+TEST_F(BuilderTest, Validations) {
+  DefineToolchain();
+  SourceDir toolchain_dir = settings_.toolchain_label().dir();
+  std::string toolchain_name = settings_.toolchain_label().name();
+
+  Label a_label(SourceDir("//a/"), "a", toolchain_dir, toolchain_name);
+  Label b_label(SourceDir("//b/"), "b", toolchain_dir, toolchain_name);
+
+  // Define A with validatation B.
+  auto a = std::make_unique<Target>(&settings_, a_label);
+  Target* a_ptr = a.get();
+  a_ptr->set_output_type(Target::ACTION);
+  a_ptr->visibility().SetPublic();
+  a_ptr->validations().push_back(LabelTargetPair(b_label));
+  builder_.ItemDefined(std::move(a));
+
+  // Should have requested that B is loaded.
+  EXPECT_TRUE(loader_->HasLoadedOne(SourceFile("//b/BUILD.gn")));
+
+  // A should NOT be resolved yet (waiting for B definition).
+  BuilderRecord* a_record = builder_.GetRecord(a_label);
+  EXPECT_TRUE(a_record);
+  EXPECT_FALSE(a_record->resolved());
+
+  // Define B. B depends on A.
+  auto b = std::make_unique<Target>(&settings_, b_label);
+  Target* b_ptr = b.get();
+  b_ptr->set_output_type(Target::ACTION);
+  b_ptr->visibility().SetPublic();
+  b_ptr->private_deps().push_back(LabelTargetPair(a_label));
+  builder_.ItemDefined(std::move(b));
+
+  scheduler().Run();
+
+  // Now both should be resolved.
+  EXPECT_TRUE(a_record->resolved());
+  BuilderRecord* b_record = builder_.GetRecord(b_label);
+  EXPECT_TRUE(b_record->resolved());
+
+  // There should be no cycle.
+  Err err;
+  EXPECT_TRUE(builder_.CheckForBadItems(&err));
+  EXPECT_FALSE(err.has_error()) << "CheckForBadItems error: " << err.message();
+
+  // A should have B in its validations.
+  ASSERT_EQ(1u, a_ptr->validations().size());
+  EXPECT_EQ(b_ptr, a_ptr->validations()[0].ptr);
+}
+
 }  // namespace gn_builder_unittest
diff --git a/src/gn/ninja_action_target_writer.cc b/src/gn/ninja_action_target_writer.cc
index 0fe0c1b..3aa5686 100644
--- a/src/gn/ninja_action_target_writer.cc
+++ b/src/gn/ninja_action_target_writer.cc
@@ -108,7 +108,9 @@
       path_output_.WriteFiles(out_, order_only_deps);
     }
 
+    WriteValidations();
     out_ << std::endl;
+
     if (target_->action_values().has_depfile()) {
       WriteDepfile(SourceFile());
     }
@@ -235,6 +237,7 @@
       out_ << " ||";
       path_output_.WriteFiles(out_, order_only_deps);
     }
+    WriteValidations();
     out_ << std::endl;
 
     // Response files require a unique name be defined.
diff --git a/src/gn/ninja_action_target_writer_unittest.cc b/src/gn/ninja_action_target_writer_unittest.cc
index 8bcea93..fa2939e 100644
--- a/src/gn/ninja_action_target_writer_unittest.cc
+++ b/src/gn/ninja_action_target_writer_unittest.cc
@@ -653,3 +653,47 @@
 )";
   EXPECT_EQ(expected, out.str()) << expected << "--" << out.str();
 }
+
+// Tests that validation dependencies are correctly written for an action
+// target.
+TEST(NinjaActionTargetWriter, ActionWithValidations) {
+  Err err;
+  TestWithScope setup;
+
+  Target validation_target(setup.settings(), Label(SourceDir("//foo/"), "val"));
+  validation_target.set_output_type(Target::ACTION);
+  validation_target.visibility().SetPublic();
+  validation_target.action_values().set_script(SourceFile("//foo/script.py"));
+  validation_target.action_values().outputs() =
+      SubstitutionList::MakeForTest("//out/Debug/val.out");
+  validation_target.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(validation_target.OnResolved(&err));
+
+  Target target(setup.settings(), Label(SourceDir("//foo/"), "bar"));
+  target.set_output_type(Target::ACTION);
+  target.action_values().set_script(SourceFile("//foo/script.py"));
+  target.action_values().outputs() =
+      SubstitutionList::MakeForTest("//out/Debug/foo.out");
+  target.validations().push_back(LabelTargetPair(&validation_target));
+  target.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(target.OnResolved(&err)) << err.message();
+
+  setup.build_settings()->SetPythonPath(
+      base::FilePath(FILE_PATH_LITERAL("/usr/bin/python")));
+
+  std::ostringstream out;
+  NinjaActionTargetWriter writer(&target, out);
+  writer.Run();
+
+  const char expected[] =
+      "rule __foo_bar___rule\n"
+      "  command = /usr/bin/python ../../foo/script.py\n"
+      "  description = ACTION //foo:bar()\n"
+      "  restat = 1\n"
+      "\n"
+      "build foo.out: __foo_bar___rule | ../../foo/script.py |@ phony/foo/val\n"
+      "\n"
+      "build phony/foo/bar: phony foo.out |@ phony/foo/val\n";
+
+  EXPECT_EQ(expected, out.str());
+}
diff --git a/src/gn/ninja_binary_target_writer.cc b/src/gn/ninja_binary_target_writer.cc
index ac45e97..bf0da36 100644
--- a/src/gn/ninja_binary_target_writer.cc
+++ b/src/gn/ninja_binary_target_writer.cc
@@ -295,6 +295,7 @@
     out_ << " ||";
     path_output_.WriteFiles(out_, order_only_deps);
   }
+  WriteValidations();
   out_ << std::endl;
 
   if (!sources.empty() && can_write_source_info) {
diff --git a/src/gn/ninja_c_binary_target_writer.cc b/src/gn/ninja_c_binary_target_writer.cc
index c864bc0..04ea485 100644
--- a/src/gn/ninja_c_binary_target_writer.cc
+++ b/src/gn/ninja_c_binary_target_writer.cc
@@ -640,6 +640,8 @@
   // to listing them again.
   WriteOrderOnlyDependencies(classified_deps.non_linkable_deps);
 
+  WriteValidations();
+
   // End of the link "build" line.
   out_ << std::endl;
 
diff --git a/src/gn/ninja_copy_target_writer.cc b/src/gn/ninja_copy_target_writer.cc
index 47657c0..0952c6f 100644
--- a/src/gn/ninja_copy_target_writer.cc
+++ b/src/gn/ninja_copy_target_writer.cc
@@ -124,6 +124,7 @@
       path_output_.WriteFiles(out_, input_deps);
       path_output_.WriteFiles(out_, data_outs);
     }
+    WriteValidations();
     out_ << std::endl;
   }
 }
diff --git a/src/gn/ninja_copy_target_writer_unittest.cc b/src/gn/ninja_copy_target_writer_unittest.cc
index e094f80..da7da59 100644
--- a/src/gn/ninja_copy_target_writer_unittest.cc
+++ b/src/gn/ninja_copy_target_writer_unittest.cc
@@ -223,3 +223,38 @@
     EXPECT_EQ(ninja_outputs[2].value(), "phony/foo/bar");
   }
 }
+
+// Tests that validation dependencies are correctly written for a copy target.
+TEST(NinjaCopyTargetWriter, CopyWithValidations) {
+  Err err;
+  TestWithScope setup;
+
+  Target validation_target(setup.settings(), Label(SourceDir("//foo/"), "val"));
+  validation_target.set_output_type(Target::ACTION);
+  validation_target.visibility().SetPublic();
+  validation_target.action_values().set_script(SourceFile("//foo/script.py"));
+  validation_target.action_values().outputs() =
+      SubstitutionList::MakeForTest("//out/Debug/val.out");
+  validation_target.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(validation_target.OnResolved(&err));
+
+  Target target(setup.settings(), Label(SourceDir("//foo/"), "bar"));
+  target.set_output_type(Target::COPY_FILES);
+  target.sources().push_back(SourceFile("//foo/input1.txt"));
+  target.action_values().outputs() =
+      SubstitutionList::MakeForTest("//out/Debug/{{source_name_part}}.out");
+  target.validations().push_back(LabelTargetPair(&validation_target));
+  target.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(target.OnResolved(&err));
+
+  std::ostringstream out;
+  NinjaCopyTargetWriter writer(&target, out);
+  writer.Run();
+
+  const char expected_linux[] =
+      "build input1.out: copy ../../foo/input1.txt |@ phony/foo/val\n"
+      "\n"
+      "build phony/foo/bar: phony input1.out |@ phony/foo/val\n";
+  std::string out_str = out.str();
+  EXPECT_EQ(expected_linux, out_str);
+}
diff --git a/src/gn/ninja_target_writer.cc b/src/gn/ninja_target_writer.cc
index e5248a1..d6c69c7 100644
--- a/src/gn/ninja_target_writer.cc
+++ b/src/gn/ninja_target_writer.cc
@@ -627,5 +627,26 @@
     out_ << " ||";
     path_output_.WriteFiles(out_, order_only_deps);
   }
+  WriteValidations();
   out_ << std::endl;
 }
+
+void NinjaTargetWriter::WriteValidations() {
+  const LabelTargetVector& validations = target_->validations();
+  if (validations.empty())
+    return;
+
+  bool first = true;
+  for (const auto& pair : validations) {
+    // This check is needed because empty groups have no output.
+    if (!pair.ptr->has_dependency_output()) {
+      continue;
+    }
+    if (first) {
+      out_ << " |@";
+      first = false;
+    }
+    out_ << " ";
+    WriteOutput(pair.ptr->dependency_output());
+  }
+}
diff --git a/src/gn/ninja_target_writer.h b/src/gn/ninja_target_writer.h
index 68bc0a3..0936033 100644
--- a/src/gn/ninja_target_writer.h
+++ b/src/gn/ninja_target_writer.h
@@ -99,6 +99,9 @@
       const std::vector<OutputFile>& deps,
       const std::vector<OutputFile>& order_only_deps);
 
+  // Writes the validation dependencies to the output stream.
+  void WriteValidations();
+
   const Settings* settings_;  // Non-owning.
   const Target* target_;      // Non-owning.
   std::ostream& out_;
diff --git a/src/gn/ninja_target_writer_unittest.cc b/src/gn/ninja_target_writer_unittest.cc
index ae691d7..317ce2a 100644
--- a/src/gn/ninja_target_writer_unittest.cc
+++ b/src/gn/ninja_target_writer_unittest.cc
@@ -28,6 +28,12 @@
     return NinjaTargetWriter::WriteInputDepsStampOrPhonyAndGetDep(
         additional_hard_deps, num_stamp_uses);
   }
+
+  void WriteStampOrPhonyForTarget(
+      const std::vector<OutputFile>& deps,
+      const std::vector<OutputFile>& order_only_deps) {
+    NinjaTargetWriter::WriteStampOrPhonyForTarget(deps, order_only_deps);
+  }
 };
 
 }  // namespace
@@ -300,3 +306,87 @@
   EXPECT_EQ("phony/foo/setup", dep[0].value());
   EXPECT_EQ("", stream.str());
 }
+
+// Tests that validation dependencies are written to the generated Ninja file
+// with the "|@" syntax for a generic target.
+TEST(NinjaTargetWriter, WriteValidations) {
+  TestWithScope setup;
+  setup.build_settings()->set_no_stamp_files(false);
+  Err err;
+
+  Target validation_target(setup.settings(), Label(SourceDir("//foo/"), "val"));
+  validation_target.set_output_type(Target::ACTION);
+  validation_target.visibility().SetPublic();
+  validation_target.SetToolchain(setup.toolchain());
+  validation_target.action_values().set_script(SourceFile("//foo/script.py"));
+  ASSERT_TRUE(validation_target.OnResolved(&err));
+
+  Target target(setup.settings(), Label(SourceDir("//foo/"), "target"));
+  target.set_output_type(Target::GROUP);
+  target.visibility().SetPublic();
+  target.SetToolchain(setup.toolchain());
+  target.validations().push_back(LabelTargetPair(&validation_target));
+  ASSERT_TRUE(target.OnResolved(&err));
+
+  std::ostringstream stream;
+  TestingNinjaTargetWriter writer(&target, setup.toolchain(), stream);
+
+  std::vector<OutputFile> deps;
+  std::vector<OutputFile> order_only;
+  deps.push_back(OutputFile("obj/foo/target.stamp"));
+
+  writer.WriteStampOrPhonyForTarget(deps, order_only);
+
+  std::string out = stream.str();
+  EXPECT_EQ(
+      "build obj/foo/target.stamp: stamp obj/foo/target.stamp |@ "
+      "obj/foo/val.stamp\n",
+      out);
+}
+
+// Tests that if a validation target has no output (e.g., an empty group),
+// no validation dependency is written to the Ninja file.
+TEST(NinjaTargetWriter, ValidationsWithNoOutput) {
+  TestWithScope setup;
+  setup.build_settings()->set_no_stamp_files(true);
+  Err err;
+
+  // Validation target with no output (empty group, no stamp files).
+  Target validation_target(setup.settings(), Label(SourceDir("//foo/"), "val"));
+  validation_target.set_output_type(Target::GROUP);
+  validation_target.visibility().SetPublic();
+  validation_target.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(validation_target.OnResolved(&err));
+  ASSERT_FALSE(validation_target.has_dependency_output());
+
+  // A dependency that HAS an output, so 'target' will have an output alias.
+  Target real_dep(setup.settings(), Label(SourceDir("//foo/"), "dep"));
+  real_dep.set_output_type(Target::ACTION);
+  real_dep.visibility().SetPublic();
+  real_dep.SetToolchain(setup.toolchain());
+  real_dep.action_values().set_script(SourceFile("//foo/script.py"));
+  ASSERT_TRUE(real_dep.OnResolved(&err));
+
+  Target target(setup.settings(), Label(SourceDir("//foo/"), "target"));
+  target.set_output_type(Target::GROUP);
+  target.visibility().SetPublic();
+  target.SetToolchain(setup.toolchain());
+  target.public_deps().push_back(LabelTargetPair(&real_dep));
+  target.validations().push_back(LabelTargetPair(&validation_target));
+  ASSERT_TRUE(target.OnResolved(&err));
+  ASSERT_TRUE(target.has_dependency_output());
+
+  std::ostringstream stream;
+  TestingNinjaTargetWriter writer(&target, setup.toolchain(), stream);
+
+  std::vector<OutputFile> deps;
+  std::vector<OutputFile> order_only;
+  deps.push_back(OutputFile("phony/foo/dep"));
+
+  writer.WriteStampOrPhonyForTarget(deps, order_only);
+
+  std::string out = stream.str();
+  // Should not contain validation separator since the validation target has no
+  // output.
+  EXPECT_EQ("build phony/foo/target: phony phony/foo/dep\n", out);
+}
diff --git a/src/gn/target.cc b/src/gn/target.cc
index 1ea1298..9cba6af 100644
--- a/src/gn/target.cc
+++ b/src/gn/target.cc
@@ -1158,6 +1158,10 @@
     if (!Visibility::CheckItemVisibility(this, pair.ptr, err))
       return false;
   }
+  for (const auto& pair : validations_) {
+    if (!Visibility::CheckItemVisibility(this, pair.ptr, err))
+      return false;
+  }
   return true;
 }
 
@@ -1195,6 +1199,14 @@
     }
   }
 
+  // Verify no validations have "testonly" set.
+  for (const auto& pair : validations_) {
+    if (pair.ptr->testonly()) {
+      *err = MakeTestOnlyError(this, pair.ptr);
+      return false;
+    }
+  }
+
   // Verify no configs have "testonly" set.
   for (ConfigValuesIterator iter(this); !iter.done(); iter.Next()) {
     if (const Config* config = iter.GetCurrentConfig()) {
diff --git a/src/gn/target.h b/src/gn/target.h
index c8c4933..ccd5372 100644
--- a/src/gn/target.h
+++ b/src/gn/target.h
@@ -261,6 +261,10 @@
   const LabelTargetVector& data_deps() const { return data_deps_; }
   LabelTargetVector& data_deps() { return data_deps_; }
 
+  // Validation dependencies.
+  const LabelTargetVector& validations() const { return validations_; }
+  LabelTargetVector& validations() { return validations_; }
+
   // gen_deps only propagate the "should_generate" flag. These dependencies can
   // have cycles so care should be taken if iterating over them recursively.
   const LabelTargetVector& gen_deps() const { return gen_deps_; }
@@ -522,6 +526,7 @@
   LabelTargetVector private_deps_;
   LabelTargetVector public_deps_;
   LabelTargetVector data_deps_;
+  LabelTargetVector validations_;
   LabelTargetVector gen_deps_;
 
   // See getters for more info.
diff --git a/src/gn/target_generator.cc b/src/gn/target_generator.cc
index 59bcf1a..7529b2e 100644
--- a/src/gn/target_generator.cc
+++ b/src/gn/target_generator.cc
@@ -260,6 +260,8 @@
     return false;
   if (!FillGenericDeps(variables::kDataDeps, &target_->data_deps()))
     return false;
+  if (!FillGenericDeps(variables::kValidations, &target_->validations()))
+    return false;
   if (!FillGenericDeps(variables::kGenDeps, &target_->gen_deps()))
     return false;
 
diff --git a/src/gn/variables.cc b/src/gn/variables.cc
index 4573279..5090e3a 100644
--- a/src/gn/variables.cc
+++ b/src/gn/variables.cc
@@ -2212,6 +2212,33 @@
   }
 )";
 
+const char kValidations[] = "validations";
+const char kValidations_HelpShort[] =
+    "validations: [label list] Validation dependencies.";
+const char kValidations_Help[] =
+    R"(validations: Validation dependencies.
+
+  A list of target labels.
+
+  "Validations" are a list of targets that should be built if the current
+  target is built, but which do not effect the result of the current target.
+  This is used to declare things like static analysis, style checking, or
+  other checks that should run in parallel with the build.
+
+Example
+
+  executable("my_program") {
+    sources = [ "my_program.cc" ]
+    validations = [ ":my_program_style_check" ]
+  }
+
+  action("my_program_style_check") {
+    script = "//tools/style_checker.py"
+    sources = [ "my_program.cc" ]
+    outputs = [ "$target_gen_dir/my_program_style_check.stamp" ]
+  }
+)";
+
 const char kVisibility[] = "visibility";
 const char kVisibility_HelpShort[] =
     "visibility: [label list] A list of labels that can depend on a target.";
@@ -2489,6 +2516,7 @@
     INSERT_VARIABLE(XcodeTestApplicationName)
     INSERT_VARIABLE(TargetXcodePlatform)
     INSERT_VARIABLE(Testonly)
+    INSERT_VARIABLE(Validations)
     INSERT_VARIABLE(Visibility)
     INSERT_VARIABLE(WalkKeys)
     INSERT_VARIABLE(WeakFrameworks)
diff --git a/src/gn/variables.h b/src/gn/variables.h
index 2d46db4..1d953af 100644
--- a/src/gn/variables.h
+++ b/src/gn/variables.h
@@ -338,6 +338,10 @@
 extern const char kTestonly_HelpShort[];
 extern const char kTestonly_Help[];
 
+extern const char kValidations[];
+extern const char kValidations_HelpShort[];
+extern const char kValidations_Help[];
+
 extern const char kVisibility[];
 extern const char kVisibility_HelpShort[];
 extern const char kVisibility_Help[];