diff --git a/CMakeLists.txt b/CMakeLists.txt
index 78243b7..5af5114 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -260,6 +260,7 @@
     src/disk_interface_test.cc
     src/dyndep_parser_test.cc
     src/edit_distance_test.cc
+    src/explanations_test.cc
     src/graph_test.cc
     src/json_test.cc
     src/lexer_test.cc
diff --git a/configure.py b/configure.py
index 2b16618..c88daad 100755
--- a/configure.py
+++ b/configure.py
@@ -638,6 +638,7 @@
         'disk_interface_test',
         'dyndep_parser_test',
         'edit_distance_test',
+        'explanations_test',
         'graph_test',
         'json_test',
         'lexer_test',
diff --git a/src/build.cc b/src/build.cc
index e05a3d2..deb8f04 100644
--- a/src/build.cc
+++ b/src/build.cc
@@ -34,6 +34,7 @@
 #include "depfile_parser.h"
 #include "deps_log.h"
 #include "disk_interface.h"
+#include "explanations.h"
 #include "graph.h"
 #include "metrics.h"
 #include "state.h"
@@ -669,22 +670,24 @@
   return true;
 }
 
-Builder::Builder(State* state, const BuildConfig& config,
-                 BuildLog* build_log, DepsLog* deps_log,
-                 DiskInterface* disk_interface, Status *status,
-                 int64_t start_time_millis)
+Builder::Builder(State* state, const BuildConfig& config, BuildLog* build_log,
+                 DepsLog* deps_log, DiskInterface* disk_interface,
+                 Status* status, int64_t start_time_millis)
     : state_(state), config_(config), plan_(this), status_(status),
       start_time_millis_(start_time_millis), disk_interface_(disk_interface),
+      explanations_(g_explaining ? new Explanations() : nullptr),
       scan_(state, build_log, deps_log, disk_interface,
-            &config_.depfile_parser_options) {
+            &config_.depfile_parser_options, explanations_.get()) {
   lock_file_path_ = ".ninja_lock";
   string build_dir = state_->bindings_.LookupVariable("builddir");
   if (!build_dir.empty())
     lock_file_path_ = build_dir + "/" + lock_file_path_;
+  status_->SetExplanations(explanations_.get());
 }
 
 Builder::~Builder() {
   Cleanup();
+  status_->SetExplanations(nullptr);
 }
 
 void Builder::Cleanup() {
diff --git a/src/build.h b/src/build.h
index 471f0b2..9bb0c70 100644
--- a/src/build.h
+++ b/src/build.h
@@ -22,14 +22,15 @@
 #include <vector>
 
 #include "depfile_parser.h"
-#include "graph.h"
 #include "exit_status.h"
+#include "graph.h"
 #include "util.h"  // int64_t
 
 struct BuildLog;
 struct Builder;
 struct DiskInterface;
 struct Edge;
+struct Explanations;
 struct Node;
 struct State;
 struct Status;
@@ -186,9 +187,8 @@
 
 /// Builder wraps the build process: starting commands, updating status.
 struct Builder {
-  Builder(State* state, const BuildConfig& config,
-          BuildLog* build_log, DepsLog* deps_log,
-          DiskInterface* disk_interface, Status* status,
+  Builder(State* state, const BuildConfig& config, BuildLog* build_log,
+          DepsLog* deps_log, DiskInterface* disk_interface, Status* status,
           int64_t start_time_millis);
   ~Builder();
 
@@ -242,6 +242,10 @@
 
   std::string lock_file_path_;
   DiskInterface* disk_interface_;
+
+  // Only create an Explanations class if '-d explain' is used.
+  std::unique_ptr<Explanations> explanations_;
+
   DependencyScan scan_;
 
   // Unimplemented copy ctor and operator= ensure we don't copy the auto_ptr.
diff --git a/src/debug_flags.cc b/src/debug_flags.cc
index e90d8f3..c83abb4 100644
--- a/src/debug_flags.cc
+++ b/src/debug_flags.cc
@@ -26,21 +26,3 @@
 bool g_keep_rsp = false;
 
 bool g_experimental_statcache = true;
-
-// Reasons each Node needs rebuilding, for "-d explain".
-typedef std::map<const Node*, std::vector<std::string> > Explanations;
-static Explanations explanations_;
-
-void record_explanation(const Node* node, std::string explanation) {
-  explanations_[node].push_back(explanation);
-}
-
-void print_explanations(FILE *stream, const Edge* edge) {
-  for (std::vector<Node*>::const_iterator o = edge->outputs_.begin();
-       o != edge->outputs_.end(); ++o) {
-    for (std::vector<std::string>::iterator s = explanations_[*o].begin();
-         s != explanations_[*o].end(); ++s) {
-      fprintf(stream, "ninja explain: %s\n", (*s).c_str());
-    }
-  }
-}
diff --git a/src/debug_flags.h b/src/debug_flags.h
index d2480bb..fe73a52 100644
--- a/src/debug_flags.h
+++ b/src/debug_flags.h
@@ -17,20 +17,10 @@
 
 #include <stdio.h>
 
-#define EXPLAIN(node, fmt, ...) {                                       \
-  if (g_explaining) {                                                   \
-    char buf[1024];                                                     \
-    snprintf(buf, 1024, fmt, __VA_ARGS__);                              \
-    record_explanation(node, buf);                                      \
-  }                                                                     \
-}
-
 struct Edge;
 struct Node;
 
 extern bool g_explaining;
-void record_explanation(const Node* node, std::string reason);
-void print_explanations(FILE *stream, const Edge* node);
 
 extern bool g_keep_depfile;
 
diff --git a/src/disk_interface_test.cc b/src/disk_interface_test.cc
index e8d869c..b09ed04 100644
--- a/src/disk_interface_test.cc
+++ b/src/disk_interface_test.cc
@@ -259,7 +259,7 @@
 
 struct StatTest : public StateTestWithBuiltinRules,
                   public DiskInterface {
-  StatTest() : scan_(&state_, NULL, NULL, this, NULL) {}
+  StatTest() : scan_(&state_, NULL, NULL, this, NULL, NULL) {}
 
   // DiskInterface implementation.
   virtual TimeStamp Stat(const string& path, string* err) const;
diff --git a/src/dyndep.cc b/src/dyndep.cc
index 1eadbcb..15e6984 100644
--- a/src/dyndep.cc
+++ b/src/dyndep.cc
@@ -20,6 +20,7 @@
 #include "debug_flags.h"
 #include "disk_interface.h"
 #include "dyndep_parser.h"
+#include "explanations.h"
 #include "graph.h"
 #include "state.h"
 #include "util.h"
@@ -37,7 +38,8 @@
   node->set_dyndep_pending(false);
 
   // Load the dyndep information from the file.
-  EXPLAIN(node, "loading dyndep file '%s'", node->path().c_str());
+  explanations_.Record(node, "loading dyndep file '%s'", node->path().c_str());
+
   if (!LoadDyndepFile(node, ddf, err))
     return false;
 
diff --git a/src/dyndep.h b/src/dyndep.h
index 907f921..5999800 100644
--- a/src/dyndep.h
+++ b/src/dyndep.h
@@ -19,6 +19,8 @@
 #include <string>
 #include <vector>
 
+#include "explanations.h"
+
 struct DiskInterface;
 struct Edge;
 struct Node;
@@ -42,8 +44,10 @@
 /// DyndepLoader loads dynamically discovered dependencies, as
 /// referenced via the "dyndep" attribute in build files.
 struct DyndepLoader {
-  DyndepLoader(State* state, DiskInterface* disk_interface)
-      : state_(state), disk_interface_(disk_interface) {}
+  DyndepLoader(State* state, DiskInterface* disk_interface,
+               Explanations* explanations = nullptr)
+      : state_(state), disk_interface_(disk_interface),
+        explanations_(explanations) {}
 
   /// Load a dyndep file from the given node's path and update the
   /// build graph with the new information.  One overload accepts
@@ -59,6 +63,7 @@
 
   State* state_;
   DiskInterface* disk_interface_;
+  mutable OptionalExplanations explanations_;
 };
 
 #endif  // NINJA_DYNDEP_LOADER_H_
diff --git a/src/explanations.h b/src/explanations.h
new file mode 100644
index 0000000..babebd4
--- /dev/null
+++ b/src/explanations.h
@@ -0,0 +1,89 @@
+// Copyright 2024 Google Inc. All Rights Reserved.
+//
+// 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.
+
+#pragma once
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+/// A class used to record a list of explanation strings associated
+/// with a given 'item' pointer. This is used to implement the
+/// `-d explain` feature.
+struct Explanations {
+ public:
+  /// Record an explanation for |item| if this instance is enabled.
+  void Record(const void* item, const char* fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    RecordArgs(item, fmt, args);
+    va_end(args);
+  }
+
+  /// Same as Record(), but uses a va_list to pass formatting arguments.
+  void RecordArgs(const void* item, const char* fmt, va_list args) {
+    char buffer[1024];
+    vsnprintf(buffer, sizeof(buffer), fmt, args);
+    map_[item].emplace_back(buffer);
+  }
+
+  /// Lookup the explanations recorded for |item|, and append them
+  /// to |*out|, if any.
+  void LookupAndAppend(const void* item, std::vector<std::string>* out) {
+    auto it = map_.find(item);
+    if (it == map_.end())
+      return;
+
+    for (const auto& explanation : it->second)
+      out->push_back(explanation);
+  }
+
+ private:
+  bool enabled_ = false;
+  std::unordered_map<const void*, std::vector<std::string>> map_;
+};
+
+/// Convenience wrapper for an Explanations pointer, which can be null
+/// if no explanations need to be recorded.
+struct OptionalExplanations {
+  OptionalExplanations(Explanations* explanations)
+      : explanations_(explanations) {}
+
+  void Record(const void* item, const char* fmt, ...) {
+    if (explanations_) {
+      va_list args;
+      va_start(args, fmt);
+      explanations_->RecordArgs(item, fmt, args);
+      va_end(args);
+    }
+  }
+
+  void RecordArgs(const void* item, const char* fmt, va_list args) {
+    if (explanations_)
+      explanations_->RecordArgs(item, fmt, args);
+  }
+
+  void LookupAndAppend(const void* item, std::vector<std::string>* out) {
+    if (explanations_)
+      explanations_->LookupAndAppend(item, out);
+  }
+
+  Explanations* ptr() const { return explanations_; }
+
+ private:
+  Explanations* explanations_;
+};
diff --git a/src/explanations_test.cc b/src/explanations_test.cc
new file mode 100644
index 0000000..e46600f
--- /dev/null
+++ b/src/explanations_test.cc
@@ -0,0 +1,97 @@
+// Copyright 2024 Google Inc. All Rights Reserved.
+//
+// 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 "explanations.h"
+
+#include "test.h"
+
+namespace {
+
+const void* MakeItem(size_t v) {
+  return reinterpret_cast<const void*>(v);
+}
+
+}  // namespace
+
+TEST(Explanations, Explanations) {
+  Explanations exp;
+
+  exp.Record(MakeItem(1), "first explanation");
+  exp.Record(MakeItem(1), "second explanation");
+  exp.Record(MakeItem(2), "third explanation");
+  exp.Record(MakeItem(2), "fourth %s", "explanation");
+
+  std::vector<std::string> list;
+
+  exp.LookupAndAppend(MakeItem(0), &list);
+  ASSERT_TRUE(list.empty());
+
+  exp.LookupAndAppend(MakeItem(1), &list);
+  ASSERT_EQ(2u, list.size());
+  EXPECT_EQ(list[0], "first explanation");
+  EXPECT_EQ(list[1], "second explanation");
+
+  exp.LookupAndAppend(MakeItem(2), &list);
+  ASSERT_EQ(4u, list.size());
+  EXPECT_EQ(list[0], "first explanation");
+  EXPECT_EQ(list[1], "second explanation");
+  EXPECT_EQ(list[2], "third explanation");
+  EXPECT_EQ(list[3], "fourth explanation");
+}
+
+TEST(Explanations, OptionalExplanationsNonNull) {
+  Explanations parent;
+  OptionalExplanations exp(&parent);
+
+  exp.Record(MakeItem(1), "first explanation");
+  exp.Record(MakeItem(1), "second explanation");
+  exp.Record(MakeItem(2), "third explanation");
+  exp.Record(MakeItem(2), "fourth %s", "explanation");
+
+  std::vector<std::string> list;
+
+  exp.LookupAndAppend(MakeItem(0), &list);
+  ASSERT_TRUE(list.empty());
+
+  exp.LookupAndAppend(MakeItem(1), &list);
+  ASSERT_EQ(2u, list.size());
+  EXPECT_EQ(list[0], "first explanation");
+  EXPECT_EQ(list[1], "second explanation");
+
+  exp.LookupAndAppend(MakeItem(2), &list);
+  ASSERT_EQ(4u, list.size());
+  EXPECT_EQ(list[0], "first explanation");
+  EXPECT_EQ(list[1], "second explanation");
+  EXPECT_EQ(list[2], "third explanation");
+  EXPECT_EQ(list[3], "fourth explanation");
+}
+
+TEST(Explanations, OptionalExplanationsWithNullPointer) {
+  OptionalExplanations exp(nullptr);
+
+  exp.Record(MakeItem(1), "first explanation");
+  exp.Record(MakeItem(1), "second explanation");
+  exp.Record(MakeItem(2), "third explanation");
+  exp.Record(MakeItem(2), "fourth %s", "explanation");
+
+  std::vector<std::string> list;
+  exp.LookupAndAppend(MakeItem(0), &list);
+  ASSERT_TRUE(list.empty());
+
+  exp.LookupAndAppend(MakeItem(1), &list);
+  ASSERT_TRUE(list.empty());
+
+  exp.LookupAndAppend(MakeItem(2), &list);
+  ASSERT_TRUE(list.empty());
+}
diff --git a/src/graph.cc b/src/graph.cc
index 0156a89..143eabd 100644
--- a/src/graph.cc
+++ b/src/graph.cc
@@ -91,7 +91,8 @@
     if (!node->StatIfNecessary(disk_interface_, err))
       return false;
     if (!node->exists())
-      EXPLAIN(node, "%s has no in-edge and is missing", node->path().c_str());
+      explanations_.Record(node, "%s has no in-edge and is missing",
+                           node->path().c_str());
     node->set_dirty(!node->exists());
     return true;
   }
@@ -151,7 +152,7 @@
       if (!err->empty())
         return false;
       // Failed to load dependency info: rebuild to regenerate it.
-      // LoadDeps() did EXPLAIN() already, no need to do it here.
+      // LoadDeps() did explanations_->Record() already, no need to do it here.
       dirty = edge->deps_missing_ = true;
     }
   }
@@ -182,7 +183,7 @@
       // If a regular input is dirty (or missing), we're dirty.
       // Otherwise consider mtime.
       if ((*i)->dirty()) {
-        EXPLAIN(node, "%s is dirty", (*i)->path().c_str());
+        explanations_.Record(node, "%s is dirty", (*i)->path().c_str());
         dirty = true;
       } else {
         if (!most_recent_input || (*i)->mtime() > most_recent_input->mtime()) {
@@ -282,8 +283,9 @@
     // Phony edges don't write any output.  Outputs are only dirty if
     // there are no inputs and we're missing the output.
     if (edge->inputs_.empty() && !output->exists()) {
-      EXPLAIN(output, "output %s of phony edge with no inputs doesn't exist",
-              output->path().c_str());
+      explanations_.Record(
+          output, "output %s of phony edge with no inputs doesn't exist",
+          output->path().c_str());
       return true;
     }
 
@@ -299,7 +301,8 @@
 
   // Dirty if we're missing the output.
   if (!output->exists()) {
-    EXPLAIN(output, "output %s doesn't exist", output->path().c_str());
+    explanations_.Record(output, "output %s doesn't exist",
+                         output->path().c_str());
     return true;
   }
 
@@ -319,11 +322,12 @@
 
   // Dirty if the output is older than the input.
   if (!used_restat && most_recent_input && output->mtime() < most_recent_input->mtime()) {
-    EXPLAIN(output, "output %s older than most recent input %s "
-            "(%" PRId64 " vs %" PRId64 ")",
-            output->path().c_str(),
-            most_recent_input->path().c_str(),
-            output->mtime(), most_recent_input->mtime());
+    explanations_.Record(output,
+                         "output %s older than most recent input %s "
+                         "(%" PRId64 " vs %" PRId64 ")",
+                         output->path().c_str(),
+                         most_recent_input->path().c_str(), output->mtime(),
+                         most_recent_input->mtime());
     return true;
   }
 
@@ -335,7 +339,8 @@
         // May also be dirty due to the command changing since the last build.
         // But if this is a generator rule, the command changing does not make us
         // dirty.
-        EXPLAIN(output, "command line changed for %s", output->path().c_str());
+        explanations_.Record(output, "command line changed for %s",
+                             output->path().c_str());
         return true;
       }
       if (most_recent_input && entry->mtime < most_recent_input->mtime()) {
@@ -345,16 +350,18 @@
         // exited with an error or was interrupted. If this was a restat rule,
         // then we only check the recorded mtime against the most recent input
         // mtime and ignore the actual output's mtime above.
-        EXPLAIN(output,
-                "recorded mtime of %s older than most recent input %s (%" PRId64 " vs %" PRId64 ")",
-                output->path().c_str(), most_recent_input->path().c_str(),
-                entry->mtime, most_recent_input->mtime());
+        explanations_.Record(
+            output,
+            "recorded mtime of %s older than most recent input %s (%" PRId64
+            " vs %" PRId64 ")",
+            output->path().c_str(), most_recent_input->path().c_str(),
+            entry->mtime, most_recent_input->mtime());
         return true;
       }
     }
     if (!entry && !generator) {
-      EXPLAIN(output, "command line not found in log for %s",
-              output->path().c_str());
+      explanations_.Record(output, "command line not found in log for %s",
+                           output->path().c_str());
       return true;
     }
   }
@@ -670,7 +677,7 @@
   // On a missing depfile: return false and empty *err.
   Node* first_output = edge->outputs_[0];
   if (content.empty()) {
-    EXPLAIN(first_output, "depfile '%s' is missing", path.c_str());
+    explanations_.Record(first_output, "depfile '%s' is missing", path.c_str());
     return false;
   }
 
@@ -697,9 +704,10 @@
   // mark the edge as dirty.
   StringPiece opath = StringPiece(first_output->path());
   if (opath != *primary_out) {
-    EXPLAIN(first_output, "expected depfile '%s' to mention '%s', got '%s'",
-            path.c_str(), first_output->path().c_str(),
-            primary_out->AsString().c_str());
+    explanations_.Record(first_output,
+                         "expected depfile '%s' to mention '%s', got '%s'",
+                         path.c_str(), first_output->path().c_str(),
+                         primary_out->AsString().c_str());
     return false;
   }
 
@@ -740,15 +748,17 @@
   Node* output = edge->outputs_[0];
   DepsLog::Deps* deps = deps_log_ ? deps_log_->GetDeps(output) : NULL;
   if (!deps) {
-    EXPLAIN(output, "deps for '%s' are missing", output->path().c_str());
+    explanations_.Record(output, "deps for '%s' are missing",
+                         output->path().c_str());
     return false;
   }
 
   // Deps are invalid if the output is newer than the deps.
   if (output->mtime() > deps->mtime) {
-    EXPLAIN(output,
-            "stored deps info out of date for '%s' (%" PRId64 " vs %" PRId64 ")",
-            output->path().c_str(), deps->mtime, output->mtime());
+    explanations_.Record(output,
+                         "stored deps info out of date for '%s' (%" PRId64
+                         " vs %" PRId64 ")",
+                         output->path().c_str(), deps->mtime, output->mtime());
     return false;
   }
 
diff --git a/src/graph.h b/src/graph.h
index 820a265..314c442 100644
--- a/src/graph.h
+++ b/src/graph.h
@@ -16,13 +16,14 @@
 #define NINJA_GRAPH_H_
 
 #include <algorithm>
+#include <queue>
 #include <set>
 #include <string>
 #include <vector>
-#include <queue>
 
 #include "dyndep.h"
 #include "eval_env.h"
+#include "explanations.h"
 #include "timestamp.h"
 #include "util.h"
 
@@ -283,9 +284,11 @@
 struct ImplicitDepLoader {
   ImplicitDepLoader(State* state, DepsLog* deps_log,
                     DiskInterface* disk_interface,
-                    DepfileParserOptions const* depfile_parser_options)
+                    DepfileParserOptions const* depfile_parser_options,
+                    Explanations* explanations)
       : state_(state), disk_interface_(disk_interface), deps_log_(deps_log),
-        depfile_parser_options_(depfile_parser_options) {}
+        depfile_parser_options_(depfile_parser_options),
+        explanations_(explanations) {}
 
   /// Load implicit dependencies for \a edge.
   /// @return false on error (without filling \a err if info is just missing
@@ -319,6 +322,7 @@
   DiskInterface* disk_interface_;
   DepsLog* deps_log_;
   DepfileParserOptions const* depfile_parser_options_;
+  OptionalExplanations explanations_;
 };
 
 
@@ -327,11 +331,12 @@
 struct DependencyScan {
   DependencyScan(State* state, BuildLog* build_log, DepsLog* deps_log,
                  DiskInterface* disk_interface,
-                 DepfileParserOptions const* depfile_parser_options)
-      : build_log_(build_log),
-        disk_interface_(disk_interface),
-        dep_loader_(state, deps_log, disk_interface, depfile_parser_options),
-        dyndep_loader_(state, disk_interface) {}
+                 DepfileParserOptions const* depfile_parser_options,
+                 Explanations* explanations)
+      : build_log_(build_log), disk_interface_(disk_interface),
+        dep_loader_(state, deps_log, disk_interface, depfile_parser_options,
+                    explanations),
+        dyndep_loader_(state, disk_interface), explanations_(explanations) {}
 
   /// Update the |dirty_| state of the given nodes by transitively inspecting
   /// their input edges.
@@ -375,10 +380,13 @@
   bool RecomputeOutputDirty(const Edge* edge, const Node* most_recent_input,
                             const std::string& command, Node* output);
 
+  void RecordExplanation(const Node* node, const char* fmt, ...);
+
   BuildLog* build_log_;
   DiskInterface* disk_interface_;
   ImplicitDepLoader dep_loader_;
   DyndepLoader dyndep_loader_;
+  OptionalExplanations explanations_;
 };
 
 // Implements a less comparison for edges by priority, where highest
diff --git a/src/graph_test.cc b/src/graph_test.cc
index fb0513c..f909b90 100644
--- a/src/graph_test.cc
+++ b/src/graph_test.cc
@@ -13,14 +13,14 @@
 // limitations under the License.
 
 #include "graph.h"
-#include "build.h"
 
+#include "build.h"
 #include "test.h"
 
 using namespace std;
 
 struct GraphTest : public StateTestWithBuiltinRules {
-  GraphTest() : scan_(&state_, NULL, NULL, &fs_, NULL) {}
+  GraphTest() : scan_(&state_, NULL, NULL, &fs_, NULL, NULL) {}
 
   VirtualFileSystem fs_;
   DependencyScan scan_;
diff --git a/src/missing_deps.cc b/src/missing_deps.cc
index de76620..f96a5e7 100644
--- a/src/missing_deps.cc
+++ b/src/missing_deps.cc
@@ -33,9 +33,9 @@
   NodeStoringImplicitDepLoader(
       State* state, DepsLog* deps_log, DiskInterface* disk_interface,
       DepfileParserOptions const* depfile_parser_options,
-      std::vector<Node*>* dep_nodes_output)
+      Explanations* explanations, std::vector<Node*>* dep_nodes_output)
       : ImplicitDepLoader(state, deps_log, disk_interface,
-                          depfile_parser_options),
+                          depfile_parser_options, explanations),
         dep_nodes_output_(dep_nodes_output) {}
 
  protected:
@@ -98,7 +98,8 @@
     DepfileParserOptions parser_opts;
     std::vector<Node*> depfile_deps;
     NodeStoringImplicitDepLoader dep_loader(state_, deps_log_, disk_interface_,
-                                            &parser_opts, &depfile_deps);
+                                            &parser_opts, nullptr,
+                                            &depfile_deps);
     std::string err;
     dep_loader.LoadDeps(edge, &err);
     if (!depfile_deps.empty())
diff --git a/src/status.h b/src/status.h
index e38b4e6..29db7c2 100644
--- a/src/status.h
+++ b/src/status.h
@@ -19,6 +19,7 @@
 
 struct BuildConfig;
 struct Edge;
+struct Explanations;
 
 /// Abstract interface to object that tracks the status of a build:
 /// completion fraction, printing updates.
@@ -33,6 +34,11 @@
   virtual void BuildStarted() = 0;
   virtual void BuildFinished() = 0;
 
+  /// Set the Explanations instance to use to report explanations,
+  /// argument can be nullptr if no explanations need to be printed
+  /// (which is the default).
+  virtual void SetExplanations(Explanations*) = 0;
+
   virtual void Info(const char* msg, ...) = 0;
   virtual void Warning(const char* msg, ...) = 0;
   virtual void Error(const char* msg, ...) = 0;
diff --git a/src/status_printer.cc b/src/status_printer.cc
index 577aa93..7d8167e 100644
--- a/src/status_printer.cc
+++ b/src/status_printer.cc
@@ -403,11 +403,20 @@
 }
 
 void StatusPrinter::PrintStatus(const Edge* edge, int64_t time_millis) {
-  if (g_explaining) {
-    // Start a new line so that the first explanation does not append to the
-    // status line.
-    printer_.PrintOnNewLine("");
-    print_explanations(stderr, edge);
+  if (explanations_) {
+    // Collect all explanations for the current edge's outputs.
+    std::vector<std::string> explanations;
+    for (Node* output : edge->outputs_) {
+      explanations_->LookupAndAppend(output, &explanations);
+    }
+    if (!explanations.empty()) {
+      // Start a new line so that the first explanation does not append to the
+      // status line.
+      printer_.PrintOnNewLine("");
+      for (const auto& exp : explanations) {
+        fprintf(stderr, "ninja explain: %s\n", exp.c_str());
+      }
+    }
   }
 
   if (config_.verbosity == BuildConfig::QUIET
diff --git a/src/status_printer.h b/src/status_printer.h
index 1681fb8..0fa3a90 100644
--- a/src/status_printer.h
+++ b/src/status_printer.h
@@ -16,6 +16,7 @@
 #include <cstdint>
 #include <queue>
 
+#include "explanations.h"
 #include "line_printer.h"
 #include "status.h"
 
@@ -49,6 +50,11 @@
   std::string FormatProgressStatus(const char* progress_status_format,
                                    int64_t time_millis) const;
 
+  /// Set the |explanations_| pointer. Used to implement `-d explain`.
+  void SetExplanations(Explanations* explanations) override {
+    explanations_ = explanations;
+  }
+
  private:
   void PrintStatus(const Edge* edge, int64_t time_millis);
 
@@ -83,6 +89,9 @@
   /// Prints progress output.
   LinePrinter printer_;
 
+  /// An optional Explaantions pointer, used to implement `-d explain`.
+  Explanations* explanations_ = nullptr;
+
   /// The custom progress status format to use.
   const char* progress_status_format_;