diff --git a/xls/eco/codegen_scheduled_main.cc b/xls/eco/codegen_scheduled_main.cc
new file mode 100644
index 0000000000..d74a8e0102
--- /dev/null
+++ b/xls/eco/codegen_scheduled_main.cc
@@ -0,0 +1,167 @@
+// Copyright 2024 The XLS 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 <stdbool.h>
+
+#include <cstdint>
+#include <filesystem>  // NOLINT
+#include <iostream>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "absl/flags/flag.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_format.h"
+#include "xls/codegen/module_signature.h"
+#include "xls/common/exit_status.h"
+#include "xls/common/file/filesystem.h"
+#include "xls/common/init_xls.h"
+#include "xls/common/status/ret_check.h"
+#include "xls/common/status/status_macros.h"
+#include "xls/dev_tools/tool_timeout.h"
+#include "xls/ir/function_base.h"
+#include "xls/ir/ir_parser.h"
+#include "xls/ir/verifier.h"
+#include "xls/scheduling/pipeline_schedule.h"
+#include "xls/scheduling/pipeline_schedule.pb.h"
+#include "xls/tools/codegen.h"
+#include "xls/tools/codegen_flags.h"
+#include "xls/tools/codegen_flags.pb.h"
+#include "xls/tools/scheduling_options_flags.h"
+#include "xls/tools/scheduling_options_flags.pb.h"
+
+static constexpr std::string_view kUsage = R"(
+Generates Verilog RTL from a given IR file and a schedule proto. Writes a Verilog file and a module
+signature describing the module interface to a specified location. Example
+invocations:
+
+Emit combinational module:
+   codegen_main --generator=combinational --output_verilog_path=DIR IR_FILE
+
+Emit a feed-forward pipelined module:
+   codegen_main --generator=pipeline \
+       --clock_period_ps=500 \
+       --pipeline_stages=7 \
+       --input_schedule_path=SCHEDULE_FILE \
+       IR_FILE
+)";
+ABSL_FLAG(std::string, input_schedule_path, "",
+          "Path to the IR file to patch.");  // NOLINT
+namespace xls {
+namespace {
+absl::Status RealMain(std::string_view ir_path) {
+  auto timeout = StartTimeoutTimer();
+  if (ir_path == "-") {
+    ir_path = "/dev/stdin";
+  }
+  XLS_ASSIGN_OR_RETURN(std::string ir_contents, GetFileContents(ir_path));
+  XLS_ASSIGN_OR_RETURN(std::unique_ptr<Package> p,
+                       Parser::ParsePackage(ir_contents, ir_path));
+
+  XLS_ASSIGN_OR_RETURN(CodegenFlagsProto codegen_flags_proto,
+                       GetCodegenFlags());
+  if (!codegen_flags_proto.top().empty()) {
+    XLS_RETURN_IF_ERROR(p->SetTopByName(codegen_flags_proto.top()));
+  }
+
+  XLS_RET_CHECK(p->GetTop().has_value())
+      << "Package " << p->name() << " needs a top function/proc.";
+  auto main = [&p]() -> FunctionBase* { return p->GetTop().value(); };
+
+  XLS_ASSIGN_OR_RETURN(
+      SchedulingOptionsFlagsProto scheduling_options_flags_proto,
+      GetSchedulingOptionsFlagsProto());
+  XLS_ASSIGN_OR_RETURN(PackagePipelineSchedulesProto schedule_proto,
+                       ParseTextProtoFile<PackagePipelineSchedulesProto>(
+                           absl::GetFlag(FLAGS_input_schedule_path)));
+  XLS_ASSIGN_OR_RETURN(
+      PipelineScheduleOrGroup s,
+      PipelineSchedule::FromProto(p->GetTop().value(), schedule_proto));
+  XLS_ASSIGN_OR_RETURN(CodegenResult r,
+                       Codegen(p.get(), scheduling_options_flags_proto,
+                               codegen_flags_proto, false, &s, nullptr));
+  verilog::ModuleGeneratorResult result = r.module_generator_result;
+  std::optional<PackagePipelineSchedulesProto> schedule =
+      r.package_pipeline_schedules_proto;
+
+  if (!absl::GetFlag(FLAGS_output_schedule_ir_path).empty()) {
+    XLS_RETURN_IF_ERROR(
+        SetFileContents(absl::GetFlag(FLAGS_output_schedule_ir_path),
+                        main()->package()->DumpIr()));
+  }
+
+  if (!absl::GetFlag(FLAGS_output_schedule_path).empty()) {
+    if (schedule.has_value()) {
+      XLS_RETURN_IF_ERROR(SetTextProtoFile(
+          absl::GetFlag(FLAGS_output_schedule_path), schedule.value()));
+    } else {
+      XLS_RETURN_IF_ERROR(
+          SetFileContents(absl::GetFlag(FLAGS_output_schedule_path), ""));
+    }
+  }
+
+  if (!absl::GetFlag(FLAGS_output_block_ir_path).empty()) {
+    QCHECK_GE(p->blocks().size(), 1) << "There should be at least one block "
+                                        "in the package after generating "
+                                        "module text.";
+    XLS_RETURN_IF_ERROR(SetFileContents(
+        absl::GetFlag(FLAGS_output_block_ir_path), p->DumpIr()));
+  }
+
+  if (!absl::GetFlag(FLAGS_output_signature_path).empty()) {
+    XLS_RETURN_IF_ERROR(SetTextProtoFile(
+        absl::GetFlag(FLAGS_output_signature_path), result.signature.proto()));
+  }
+
+  const std::string& verilog_path = absl::GetFlag(FLAGS_output_verilog_path);
+  if (!verilog_path.empty()) {
+    for (int64_t i = 0; i < result.verilog_line_map.mapping_size(); ++i) {
+      result.verilog_line_map.mutable_mapping(i)->set_verilog_file(
+          verilog_path);
+    }
+  }
+
+  const std::string& verilog_line_map_path =
+      absl::GetFlag(FLAGS_output_verilog_line_map_path);
+  if (!verilog_line_map_path.empty()) {
+    XLS_RETURN_IF_ERROR(
+        SetTextProtoFile(verilog_line_map_path, result.verilog_line_map));
+  }
+
+  if (verilog_path.empty()) {
+    std::cout << result.verilog_text;
+  } else {
+    XLS_RETURN_IF_ERROR(SetFileContents(verilog_path, result.verilog_text));
+  }
+  return absl::OkStatus();
+}
+
+}  // namespace
+}  // namespace xls
+
+int main(int argc, char** argv) {
+  std::vector<std::string_view> positional_arguments =
+      xls::InitXls(kUsage, argc, argv);
+
+  if (positional_arguments.size() != 1) {
+    LOG(QFATAL) << absl::StreamFormat("Expected invocation: %s IR_FILE",
+                                      argv[0]);
+  }
+  std::string_view ir_path = positional_arguments[0];
+  return xls::ExitStatus(xls::RealMain(ir_path));
+}
diff --git a/xls/eco/patch_ir.cc b/xls/eco/patch_ir.cc
new file mode 100644
index 0000000000..36028ce229
--- /dev/null
+++ b/xls/eco/patch_ir.cc
@@ -0,0 +1,526 @@
+// Copyright 2020 The XLS 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 "xls/eco/patch_ir.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <fstream>
+#include <iostream>
+#include <iterator>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#include "absl/base/attributes.h"
+#include "absl/flags/flag.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/types/span.h"
+#include "xls/common/file/filesystem.h"
+#include "xls/common/status/status_macros.h"
+#include "xls/eco/ir_patch.pb.h"
+#include "xls/estimators/delay_model/delay_estimator.h"
+#include "xls/ir/bits.h"
+#include "xls/ir/function_base.h"
+#include "xls/ir/node.h"
+#include "xls/ir/node_util.h"
+#include "xls/ir/nodes.h"
+#include "xls/ir/op.h"
+#include "xls/ir/package.h"
+#include "xls/ir/source_location.h"
+#include "xls/ir/type.h"
+#include "xls/ir/value.h"
+#include "xls/ir/value_utils.h"
+#include "xls/ir/xls_type.pb.h"
+#include "xls/ir/xls_value.pb.h"
+#include "xls/scheduling/pipeline_schedule.h"
+#include "xls/scheduling/run_pipeline_schedule.h"
+#include "xls/scheduling/scheduling_options.h"
+#include "xls/tools/codegen_flags.h"
+#include "xls/tools/scheduling_options_flags.h"
+
+namespace xls {
+
+PatchIr::PatchIr(FunctionBase* function_base, xls_eco::IrPatchProto& patch)
+    : patch_(patch), function_base_(function_base), schedule_(std::nullopt) {
+  std::copy(patch_.edit_paths().begin(), patch_.edit_paths().end(),
+            std::back_inserter(sorted_edit_paths_));
+  std::sort(sorted_edit_paths_.begin(), sorted_edit_paths_.end(),
+            [this](const xls_eco::EditPathProto& lhs,
+                   const xls_eco::EditPathProto& rhs) {
+              return this->CompareEditPaths(lhs, rhs);
+            });
+  package_ = function_base_->package();
+}
+absl::StatusOr<std::vector<Node*>> PatchIr::MakeDummyNodes(
+    absl::Span<Type*> types) {
+  std::vector<Node*> dummy_nodes;
+  for (Type* type : types) {
+    XLS_ASSIGN_OR_RETURN(Node * dummy_node, MakeDummyNode(type));
+    dummy_nodes.push_back(dummy_node);
+  }
+  return dummy_nodes;
+}
+absl::StatusOr<Node*> PatchIr::MakeDummyNode(Type* type) {
+  XLS_ASSIGN_OR_RETURN(Node * dummy_node,
+                       function_base_->MakeNodeWithName<Literal>(
+                           SourceInfo(), ZeroOfType(type), "Dummy"));
+  return dummy_node;
+}
+absl::Status PatchIr::UpdateNodeMaps(Node* n, absl::Span<Node*> dummy_operands,
+                                     std::string_view node_name) {
+  auto& dummy_nodes = dummy_nodes_map_[n];
+  dummy_nodes.insert(dummy_nodes.begin(), dummy_operands.begin(),
+                     dummy_operands.end());
+  patch_to_ir_node_map_[node_name] = n->GetName();
+  return absl::OkStatus();
+}
+absl::Status PatchIr::CleanupDummyNodes(Node* node) {
+  auto& dummy_nodes = dummy_nodes_map_[node];
+  for (auto it = dummy_nodes.begin(); it != dummy_nodes.end();) {
+    Node* dummy_node = *it;
+    XLS_RETURN_IF_ERROR(function_base_->RemoveNode(dummy_node));
+    it = dummy_nodes.erase(it);
+  }
+  return absl::OkStatus();
+}
+
+absl::StatusOr<int64_t> PatchIr::GetProtoBitCount(const TypeProto& type) {
+  XLS_ASSIGN_OR_RETURN(Type * t, package_->GetTypeFromProto(type));
+  XLS_ASSIGN_OR_RETURN(BitsType * b, t->AsBits());
+  return b->bit_count();
+}
+
+absl::Status PatchIr::PatchContainsNode(std::string_view node_name) {
+  if (patch_to_ir_node_map_.find(node_name) != patch_to_ir_node_map_.end())
+    return absl::OkStatus();
+  return absl::NotFoundError("Patch does not contain the node.");
+}
+
+absl::Status PatchIr::ApplyPatch() {
+  // XLS_RETURN_IF_ERROR(IsolateReturnNode());
+  for (const xls_eco::EditPathProto& edit_path : sorted_edit_paths_) {
+    XLS_RETURN_IF_ERROR(ApplyPath(edit_path));
+  }
+  // XLS_RETURN_IF_ERROR(RestoreReturnNode());
+  XLS_RETURN_IF_ERROR(ValidatePatch());
+  return absl::OkStatus();
+}
+
+absl::Status PatchIr::ApplyPath(const xls_eco::EditPathProto& edit_path) {
+  switch (edit_path.operation()) {
+    case xls_eco::Operation::DELETE:
+      XLS_RETURN_IF_ERROR(edit_path.has_node_edit_path()
+                              ? ApplyDeletePath(edit_path.node_edit_path())
+                              : ApplyDeletePath(edit_path.edge_edit_path()));
+      break;
+    case xls_eco::Operation::INSERT:
+      XLS_RETURN_IF_ERROR(edit_path.has_node_edit_path()
+                              ? ApplyInsertPath(edit_path.node_edit_path())
+                              : ApplyInsertPath(edit_path.edge_edit_path()));
+      break;
+    case xls_eco::Operation::UPDATE:
+      XLS_RETURN_IF_ERROR(edit_path.has_node_edit_path()
+                              ? ApplyUpdatePath(edit_path.node_edit_path())
+                              : ApplyUpdatePath(edit_path.edge_edit_path()));
+      break;
+    default:
+      return absl::InvalidArgumentError("Invalid operation");
+  }
+  return absl::OkStatus();
+}
+absl::Status PatchIr::ApplyDeletePath(
+    const xls_eco::NodeEditPathProto& node_delete) {
+  XLS_ASSIGN_OR_RETURN(Node * n,
+                       function_base_->GetNode(node_delete.node().name()));
+  XLS_RETURN_IF_ERROR(function_base_->RemoveNode(n));
+  XLS_RETURN_IF_ERROR(CleanupDummyNodes(n));
+  return absl::OkStatus();
+}
+absl::Status PatchIr::ApplyDeletePath(
+    const xls_eco::EdgeEditPathProto& edge_delete) {
+  XLS_ASSIGN_OR_RETURN(Node * from_node,
+                       function_base_->GetNode(edge_delete.edge().from_node()));
+  XLS_ASSIGN_OR_RETURN(Node * to_node,
+                       function_base_->GetNode(edge_delete.edge().to_node()));
+  XLS_ASSIGN_OR_RETURN(Node * dummy_node, MakeDummyNode(from_node->GetType()));
+  dummy_nodes_map_[to_node].push_back(dummy_node);
+  XLS_RETURN_IF_ERROR(to_node->ReplaceOperandNumber(edge_delete.edge().index(),
+                                                    dummy_node, false));
+  return absl::OkStatus();
+}
+absl::Status PatchIr::ApplyInsertPath(
+    const xls_eco::NodeEditPathProto& node_insert) {
+  const xls_eco::NodeProto& patch_node = node_insert.node();
+  if (patch_to_ir_op_map_.find(patch_node.op()) == patch_to_ir_op_map_.end()) {
+    std::cerr << "Error! Unsupported operation: " << patch_node.op() << '\n';
+    return absl::InvalidArgumentError("Unsupported operation");
+  }
+  const Op op = patch_to_ir_op_map_.at(patch_node.op());
+  std::vector<Type*> operand_types = {};
+  if (patch_node.operand_data_types_size() > 0) {
+    std::transform(patch_node.operand_data_types().begin(),
+                   patch_node.operand_data_types().end(),
+                   std::back_inserter(operand_types),
+                   [&](const TypeProto& type) {
+                     return package_->GetTypeFromProto(type).value();
+                   });
+  }
+  XLS_ASSIGN_OR_RETURN(std::vector<Node*> dummy_operands,
+                       MakeDummyNodes(absl::MakeSpan(operand_types)));
+  Node* n = nullptr;
+  switch (op) {
+    case (Op::kLiteral): {
+      XLS_ASSIGN_OR_RETURN(Value v,
+                           Value::FromProto(patch_node.unique_args(0).value()));
+      XLS_ASSIGN_OR_RETURN(n,
+                           function_base_->MakeNode<Literal>(SourceInfo(), v));
+      XLS_RETURN_IF_ERROR(
+          UpdateNodeMaps(n, absl::MakeSpan(dummy_operands), patch_node.name()));
+      break;
+    }
+    case (Op::kSignExt): {
+      XLS_ASSIGN_OR_RETURN(n,
+                           function_base_->MakeNode<ExtendOp>(
+                               SourceInfo(), dummy_operands.front(),
+                               patch_node.unique_args(0).new_bit_count(), op));
+      XLS_RETURN_IF_ERROR(
+          UpdateNodeMaps(n, absl::MakeSpan(dummy_operands), patch_node.name()));
+      break;
+    }
+    case (Op::kBitSlice): {
+      XLS_ASSIGN_OR_RETURN(int64_t width,
+                           GetProtoBitCount(patch_node.data_type()));
+      XLS_ASSIGN_OR_RETURN(n, function_base_->MakeNode<BitSlice>(
+                                  SourceInfo(), dummy_operands.front(),
+                                  patch_node.unique_args(0).start(), width));
+      XLS_RETURN_IF_ERROR(
+          UpdateNodeMaps(n, absl::MakeSpan(dummy_operands), patch_node.name()));
+      break;
+    }
+    case (Op::kTuple): {
+      XLS_ASSIGN_OR_RETURN(
+          n, function_base_->MakeNode<Tuple>(SourceInfo(),
+                                             absl::MakeSpan(dummy_operands)));
+      XLS_RETURN_IF_ERROR(
+          UpdateNodeMaps(n, absl::MakeSpan(dummy_operands), patch_node.name()));
+      break;
+    }
+    case (Op::kSMul):
+      ABSL_FALLTHROUGH_INTENDED;
+    case (Op::kUMul): {
+      XLS_ASSIGN_OR_RETURN(int64_t width,
+                           GetProtoBitCount(patch_node.data_type()));
+      XLS_ASSIGN_OR_RETURN(n, function_base_->MakeNode<ArithOp>(
+                                  SourceInfo(), dummy_operands.front(),
+                                  dummy_operands[1], width, op));
+      XLS_RETURN_IF_ERROR(
+          UpdateNodeMaps(n, absl::MakeSpan(dummy_operands), patch_node.name()));
+      break;
+    }
+    case (Op::kAdd):
+      ABSL_FALLTHROUGH_INTENDED;
+    case (Op::kSub):
+      ABSL_FALLTHROUGH_INTENDED;
+    case (Op::kULe):
+      ABSL_FALLTHROUGH_INTENDED;
+    case (Op::kULt):
+      ABSL_FALLTHROUGH_INTENDED;
+    case (Op::kUGt):
+      ABSL_FALLTHROUGH_INTENDED;
+    case (Op::kNe):
+      ABSL_FALLTHROUGH_INTENDED;
+    case (Op::kEq):
+      ABSL_FALLTHROUGH_INTENDED;
+    case (Op::kShll): {
+      XLS_ASSIGN_OR_RETURN(
+          n, function_base_->MakeNode<BinOp>(
+                 SourceInfo(), dummy_operands.front(), dummy_operands[1], op));
+      XLS_RETURN_IF_ERROR(
+          UpdateNodeMaps(n, absl::MakeSpan(dummy_operands), patch_node.name()));
+      break;
+    }
+    case (Op::kConcat): {
+      XLS_ASSIGN_OR_RETURN(
+          n, function_base_->MakeNode<Concat>(SourceInfo(),
+                                              absl::MakeSpan(dummy_operands)));
+      XLS_RETURN_IF_ERROR(
+          UpdateNodeMaps(n, absl::MakeSpan(dummy_operands), patch_node.name()));
+      break;
+    }
+    case (Op::kOrReduce): {
+      XLS_ASSIGN_OR_RETURN(n, function_base_->MakeNode<BitwiseReductionOp>(
+                                  SourceInfo(), dummy_operands.front(), op));
+      XLS_RETURN_IF_ERROR(
+          UpdateNodeMaps(n, absl::MakeSpan(dummy_operands), patch_node.name()));
+      break;
+    }
+    case (Op::kNot): {
+      XLS_ASSIGN_OR_RETURN(n, function_base_->MakeNode<UnOp>(
+                                  SourceInfo(), dummy_operands.front(), op));
+      XLS_RETURN_IF_ERROR(
+          UpdateNodeMaps(n, absl::MakeSpan(dummy_operands), patch_node.name()));
+      break;
+    }
+    case (Op::kOr):
+      ABSL_FALLTHROUGH_INTENDED;
+    case (Op::kNor):
+      ABSL_FALLTHROUGH_INTENDED;
+    case (Op::kNand):
+      ABSL_FALLTHROUGH_INTENDED;
+    case (Op::kAnd): {
+      XLS_ASSIGN_OR_RETURN(
+          n, function_base_->MakeNode<NaryOp>(
+                 SourceInfo(), absl::MakeSpan(dummy_operands), op));
+      XLS_RETURN_IF_ERROR(
+          UpdateNodeMaps(n, absl::MakeSpan(dummy_operands), patch_node.name()));
+      break;
+    }
+    case (Op::kSel): {
+      std::vector<Node*> cases;
+      std::optional<Node*> default_value;
+      if (patch_node.unique_args_size() > 0 &&
+          patch_node.unique_args(0).has_default_value()) {
+        default_value = dummy_operands.back();
+        dummy_operands.pop_back();
+      }
+      for (auto it = dummy_operands.begin() + 1; it != dummy_operands.end();
+           ++it) {
+        cases.push_back(*it);
+      }
+      XLS_ASSIGN_OR_RETURN(n, function_base_->MakeNode<Select>(
+                                  SourceInfo(), dummy_operands.front(),
+                                  absl::MakeSpan(cases), default_value));
+      XLS_RETURN_IF_ERROR(
+          UpdateNodeMaps(n, absl::MakeSpan(dummy_operands), patch_node.name()));
+      break;
+    }
+    case (Op::kOneHotSel): {
+      std::vector<Node*> cases;
+      for (auto it = dummy_operands.begin() + 1; it != dummy_operands.end();
+           ++it) {
+        cases.push_back(*it);
+      }
+      XLS_ASSIGN_OR_RETURN(
+          n, function_base_->MakeNode<OneHotSelect>(
+                 SourceInfo(), dummy_operands.front(), absl::MakeSpan(cases)));
+      XLS_RETURN_IF_ERROR(
+          UpdateNodeMaps(n, absl::MakeSpan(dummy_operands), patch_node.name()));
+      break;
+    }
+    case (Op::kParam): {
+      XLS_ASSIGN_OR_RETURN(int64_t bit_count,
+                           GetProtoBitCount(patch_node.data_type()));
+      XLS_ASSIGN_OR_RETURN(
+          n,
+          function_base_->MakeNodeWithName<Param>(
+              SourceInfo(), function_base_->package()->GetBitsType(bit_count),
+              patch_node.name()));
+      patch_to_ir_node_map_[patch_node.name()] = n->GetName();
+      break;
+    }
+    default:
+      return absl::InvalidArgumentError("Invalid operation");
+  }
+  inserted_node_names_.insert(n->GetName());
+  return absl::OkStatus();
+}
+absl::Status PatchIr::ApplyInsertPath(
+    const xls_eco::EdgeEditPathProto& edge_insert) {
+  const xls_eco::EdgeProto& patch_edge = edge_insert.edge();
+  XLS_ASSIGN_OR_RETURN(Node * from_node,
+                       PatchContainsNode(patch_edge.from_node()).ok()
+                           ? function_base_->GetNode(
+                                 patch_to_ir_node_map_[patch_edge.from_node()])
+                           : function_base_->GetNode(patch_edge.from_node()));
+  XLS_ASSIGN_OR_RETURN(
+      Node * to_node,
+      PatchContainsNode(patch_edge.to_node()).ok()
+          ? function_base_->GetNode(patch_to_ir_node_map_[patch_edge.to_node()])
+          : function_base_->GetNode(patch_edge.to_node()));
+  uint position;
+  if (commiutative_edge_index_map_.find({to_node, patch_edge.index()}) !=
+      commiutative_edge_index_map_.end()) {
+    position = commiutative_edge_index_map_.at({to_node, patch_edge.index()});
+  } else {
+    position = patch_edge.index();
+  }
+  Node* node_to_remove = to_node->operands()[position];
+  XLS_RETURN_IF_ERROR(
+      to_node->ReplaceOperandNumber(position, from_node, false));
+  XLS_RETURN_IF_ERROR(function_base_->RemoveNode(node_to_remove));
+  auto it = std::remove(dummy_nodes_map_[to_node].begin(),
+                        dummy_nodes_map_[to_node].end(), node_to_remove);
+  dummy_nodes_map_[to_node].erase(it, dummy_nodes_map_[to_node].end());
+  return absl::OkStatus();
+}
+
+absl::Status PatchIr::ApplyUpdatePath(
+    const xls_eco::NodeEditPathProto& node_update) {
+  patch_to_ir_node_map_[node_update.updated_node().name()] =
+      node_update.node().name();
+  return absl::OkStatus();
+}
+absl::Status PatchIr::ApplyUpdatePath(
+    const xls_eco::EdgeEditPathProto& edge_update) {
+  if (edge_update.edge().index() != edge_update.updated_edge().index()) {
+    XLS_ASSIGN_OR_RETURN(
+        Node * n,
+        function_base_->GetNode(
+            patch_to_ir_node_map_[edge_update.updated_edge().to_node()]));
+    commiutative_edge_index_map_[{n, edge_update.edge().index()}] =
+        edge_update.updated_edge().index();
+  }
+
+  return absl::OkStatus();
+}
+absl::Status PatchIr::IsolateReturnNode() {
+  for (Node* n : function_base_->nodes()) {
+    if (function_base_->HasImplicitUse(n)) {
+      XLS_ASSIGN_OR_RETURN(
+          dummy_return_node_,
+          function_base_->MakeNode<Literal>(
+              SourceInfo(), Value(UBits(0, n->BitCountOrDie()))));
+      XLS_RETURN_IF_ERROR(n->ReplaceUsesWith(dummy_return_node_));
+      std::cout << "Isolated return node.\n";
+      return absl::OkStatus();
+    }
+  }
+  return absl::InternalError("No return node found");
+}
+
+absl::Status PatchIr::RestoreReturnNode() {
+  Node* return_node =
+      PatchContainsNode(patch_.return_node().name()).ok()
+          ? function_base_
+                ->GetNode(patch_to_ir_node_map_[patch_.return_node().name()])
+                .value()
+          : function_base_->GetNode(patch_.return_node().name()).value();
+  XLS_RETURN_IF_ERROR(dummy_return_node_->ReplaceUsesWith(return_node));
+  XLS_RETURN_IF_ERROR(function_base_->RemoveNode(dummy_return_node_));
+  std::cout << "Reestablished return node: " << return_node->GetName() << '\n';
+  return absl::OkStatus();
+}
+absl::Status PatchIr::ValidatePatch() {
+  for (const auto& key : dummy_nodes_map_) {
+    Node* n = key.first;
+    const std::vector<Node*>& d = key.second;
+    if (!d.empty()) {
+      std::cout << "Warning! Dummy nodes in IR -> " << n->GetName()
+                << " -> Related nodes: \n";
+      for (Node* node : d) {
+        std::cout << node->GetName() << "\n";
+      }
+    }
+  }
+  return absl::OkStatus();
+}
+
+absl::Status PatchIr::PatchSchedule(const PipelineSchedule& schedule) {
+  XLS_ASSIGN_OR_RETURN(
+      SchedulingOptionsFlagsProto scheduling_options_flags_proto,
+      GetSchedulingOptionsFlagsProto());
+  XLS_ASSIGN_OR_RETURN(
+      SchedulingOptions scheduling_options,
+      SetUpSchedulingOptions(scheduling_options_flags_proto, package_));
+  SchedulingOptions tmp_scheduling_options = scheduling_options;
+  XLS_ASSIGN_OR_RETURN(DelayEstimator * delay_estimator,
+                       SetUpDelayEstimator(scheduling_options_flags_proto));
+  decltype(package_->GetNodeCount()) constraint_count = 0;
+  for (const auto& [node, cycle] : schedule.GetCycleMap()) {
+    if (inserted_node_names_.contains(node->GetName())) {
+      std::cout << "Skipping constraint for node: " << node->GetName()
+                << " due to node being newly inserted.\n";
+      continue;
+    }
+    if (std::find(function_base_->nodes().begin(),
+                  function_base_->nodes().end(),
+                  node) == function_base_->nodes().end()) {
+      std::cout << "Skipping constraint for node: " << node->GetName()
+                << " due to node not found in IR.\n";
+      continue;
+    }
+    if (node->op() == Op::kLiteral) {
+      std::cout << "Skipping constraint for node: " << node->GetName()
+                << " due to node being a literal.\n";
+      continue;
+    }
+    tmp_scheduling_options.add_constraint(NodeInCycleConstraint(node, cycle));
+    // check if schedule is feasible; if not, then we need remove the constraint
+    if (!RunPipelineSchedule(function_base_, *delay_estimator,
+                             tmp_scheduling_options)
+             .ok()) {
+      tmp_scheduling_options.clear_constraints();
+      std::cout << "Skipping constraint for node: " << node->GetName()
+                << " due to schedule infeasibility.\n";
+    } else {
+      scheduling_options = tmp_scheduling_options;
+      constraint_count++;
+    }
+    tmp_scheduling_options = scheduling_options;
+    XLS_ASSIGN_OR_RETURN(schedule_,
+                         RunPipelineSchedule(function_base_, *delay_estimator,
+                                             scheduling_options));
+  }
+  XLS_RETURN_IF_ERROR(schedule_->Verify());
+  std::cout << "Total nodes: " << package_->GetNodeCount();
+  std::cout << "constrained nodes count: " << constraint_count;
+  return absl::OkStatus();
+}
+
+absl::StatusOr<PipelineSchedule> PatchIr::GetPatchedSchedule() {
+  if (schedule_.has_value()) {
+    return schedule_.value();
+  }
+  return absl::InternalError("No schedule found");
+}
+
+absl::Status PatchIr::ExportIr(const std::string& export_path) const {
+  std::string ir_data = package_->DumpIr();
+  std::ofstream out_file(export_path);
+  if (out_file.is_open()) {
+    out_file << ir_data;
+    out_file.close();
+    return absl::OkStatus();
+  }
+  return absl::InternalError("Failed to open file: " + export_path);
+}
+absl::Status PatchIr::ExportScheduleProto() {
+  XLS_ASSIGN_OR_RETURN(
+      SchedulingOptionsFlagsProto scheduling_options_flags_proto,
+      GetSchedulingOptionsFlagsProto());
+  XLS_ASSIGN_OR_RETURN(DelayEstimator * delay_estimator,
+                       SetUpDelayEstimator(scheduling_options_flags_proto));
+  PackagePipelineSchedules package_pipeline_schedules = {
+      {function_base_, schedule_.value()}};
+  XLS_RETURN_IF_ERROR(
+      SetTextProtoFile(absl::GetFlag(FLAGS_output_schedule_path),
+                       PackagePipelineSchedulesToProto(
+                           package_pipeline_schedules, *delay_estimator)));
+  return absl::OkStatus();
+}
+bool PatchIr::CompareEditPaths(const xls_eco::EditPathProto& lhs,
+                               const xls_eco::EditPathProto& rhs) {
+  EditPathPriority lhs_priority =
+      edit_path_priority_map_[{lhs.has_node_edit_path(), lhs.operation()}];
+  EditPathPriority rhs_priority =
+      edit_path_priority_map_[{rhs.has_node_edit_path(), rhs.operation()}];
+  if (lhs_priority == rhs_priority) {
+    return lhs.id() < rhs.id();
+  }
+  return lhs_priority < rhs_priority;
+}
+}  // namespace xls
diff --git a/xls/eco/patch_ir.h b/xls/eco/patch_ir.h
new file mode 100644
index 0000000000..b82249a658
--- /dev/null
+++ b/xls/eco/patch_ir.h
@@ -0,0 +1,130 @@
+// Copyright 2020 The XLS 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 XLS_ECO_PATCH_IR_H_
+#define XLS_ECO_PATCH_IR_H_
+
+#include <cstdint>
+#include <initializer_list>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/types/span.h"
+#include "xls/eco/ir_patch.pb.h"
+#include "xls/ir/function_base.h"
+#include "xls/ir/node.h"
+#include "xls/ir/op.h"
+#include "xls/ir/package.h"
+#include "xls/ir/type.h"
+#include "xls/ir/xls_type.pb.h"
+#include "xls/ir/xls_value.pb.h"
+#include "xls/scheduling/pipeline_schedule.h"
+
+namespace xls {
+
+class PatchIr {
+ public:
+  explicit PatchIr(FunctionBase* function_base, xls_eco::IrPatchProto& patch);
+  absl::Status ApplyPatch();
+  absl::Status PrintPatch();
+  absl::Status ExportIr(const std::string& export_path) const;
+  absl::Status ExportScheduleProto();
+  absl::Status PatchSchedule(const PipelineSchedule& schedule);
+  absl::StatusOr<PipelineSchedule> GetPatchedSchedule();
+
+ private:
+  absl::Status ApplyPath(const xls_eco::EditPathProto& edit_path);
+  absl::Status ApplyDeletePath(const xls_eco::NodeEditPathProto& node_delete);
+  absl::Status ApplyDeletePath(const xls_eco::EdgeEditPathProto& edge_delete);
+  absl::Status ApplyInsertPath(const xls_eco::NodeEditPathProto& node_insert);
+  absl::Status ApplyInsertPath(const xls_eco::EdgeEditPathProto& edge_insert);
+  absl::Status ApplyUpdatePath(const xls_eco::NodeEditPathProto& node_update);
+  absl::Status ApplyUpdatePath(const xls_eco::EdgeEditPathProto& edge_update);
+  absl::flat_hash_map<xls_eco::Operation, std::string> patch_op_to_str_map_ = {
+      {xls_eco::Operation::DELETE, "delete"},
+      {xls_eco::Operation::INSERT, "insert"},
+      {xls_eco::Operation::UPDATE, "update"},
+  };
+
+  enum class EditPathPriority : uint8_t {
+    kEdgeDelete,
+    kNodeDelete,
+    kNodeUpdate,
+    kNodeInsert,
+    kEdgeUpdate,
+    kEdgeInsert,
+  };
+  absl::flat_hash_map<std::pair<bool, xls_eco::Operation>, EditPathPriority>
+      edit_path_priority_map_ = {
+          {{true, xls_eco::UPDATE}, EditPathPriority::kNodeUpdate},
+          {{true, xls_eco::INSERT}, EditPathPriority::kNodeInsert},
+          {{true, xls_eco::DELETE}, EditPathPriority::kNodeDelete},
+          {{false, xls_eco::UPDATE}, EditPathPriority::kEdgeUpdate},
+          {{false, xls_eco::INSERT}, EditPathPriority::kEdgeInsert},
+          {{false, xls_eco::DELETE}, EditPathPriority::kEdgeDelete},
+  };
+
+  absl::flat_hash_map<std::string, Op> patch_to_ir_op_map_{
+      {"literal", Op::kLiteral},
+      {"param", Op::kParam},
+      {"sub", Op::kSub},
+      {"add", Op::kAdd},
+      {"umul", Op::kUMul},
+      {"smul", Op::kSMul},
+      {"concat", Op::kConcat},
+      {"bit_slice", Op::kBitSlice},
+      {"one_hot_sel", Op::kOneHotSel},
+      {"or", Op::kOr},
+      {"and", Op::kAnd},
+      {"nand", Op::kNand},
+      {"nor", Op::kNor},
+      {"not", Op::kNot},
+      {"sel", Op::kSel},
+      {"or_reduce", Op::kOrReduce},
+      {"tuple", Op::kTuple},
+      {"sign_ext", Op::kSignExt}};
+
+  bool CompareEditPaths(const xls_eco::EditPathProto& lhs,
+                        const xls_eco::EditPathProto& rhs);
+  absl::StatusOr<std::vector<Node*>> MakeDummyNodes(absl::Span<Type*> types);
+  absl::StatusOr<Node*> MakeDummyNode(Type* type);
+  absl::StatusOr<int64_t> GetProtoBitCount(const TypeProto& type);
+  absl::Status UpdateNodeMaps(Node* n, absl::Span<Node*> dummy_operands,
+                              std::string_view node_name);
+  absl::Status CleanupDummyNodes(Node* node);
+  xls_eco::IrPatchProto patch_;
+  std::vector<xls_eco::EditPathProto> sorted_edit_paths_;
+  absl::flat_hash_set<std::string> inserted_node_names_;
+  FunctionBase* function_base_;
+  Package* package_;
+  std::optional<PipelineSchedule> schedule_;
+  absl::flat_hash_map<Node*, std::vector<Node*>> dummy_nodes_map_;
+  Node* dummy_return_node_ = nullptr;
+  absl::flat_hash_map<std::string, std::string> patch_to_ir_node_map_;
+  absl::flat_hash_map<std::pair<Node*, uint>, uint>
+      commiutative_edge_index_map_;
+  absl::Status IsolateReturnNode();
+  absl::Status RestoreReturnNode();
+  absl::Status ValidatePatch();
+  absl::Status PatchContainsNode(std::string_view node_name);
+};
+
+}  // namespace xls
+#endif  // PLATFORMS_HLS_XLS_ECO_PATCH_IR_H_
diff --git a/xls/eco/patch_ir_main.cc b/xls/eco/patch_ir_main.cc
new file mode 100644
index 0000000000..289210a8e3
--- /dev/null
+++ b/xls/eco/patch_ir_main.cc
@@ -0,0 +1,122 @@
+// Copyright 2020 The XLS 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 <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "absl/flags/flag.h"
+#include "absl/log/check.h"
+#include "absl/status/status.h"
+#include "xls/common/exit_status.h"
+#include "xls/common/file/filesystem.h"
+#include "xls/common/init_xls.h"
+#include "xls/common/status/status_macros.h"
+#include "xls/eco/ir_patch.pb.h"
+#include "xls/eco/patch_ir.h"
+#include "xls/ir/function_base.h"
+#include "xls/ir/ir_parser.h"
+#include "xls/ir/node.h"
+#include "xls/ir/package.h"
+#include "xls/scheduling/pipeline_schedule.h"
+#include "xls/scheduling/pipeline_schedule.pb.h"
+#include "xls/scheduling/scheduling_options.h"
+
+static constexpr std::string_view kUsage = R"(
+Ptaches a given IR with a given patch generated by ir_patch_gen.py. The
+optional schedule file is used to constrain the schedule of the patched IR.
+
+Example invocation:
+  patch_ir_main -i <ir file> -p <patch file> -o <patched ir file> -s <schedule file>
+)";
+
+ABSL_FLAG(std::string, input_ir_path, "",
+          "Path to the IR file to patch.");  // NOLINT
+ABSL_FLAG(std::string, input_patch_path, "",
+          "Path to the patch file.");  // NOLINT
+ABSL_FLAG(std::string, output_ir_path, "",
+          "Path to the patched IR file.");  // NOLINT
+ABSL_FLAG(std::optional<std::string>, input_schedule_path, std::nullopt,
+          "Path to the schedule file.");  // NOLINT
+
+namespace xls {
+static absl::StatusOr<PipelineSchedule> PipelineScheduleFromProto(
+    FunctionBase* function,
+    const PackagePipelineSchedulesProto& package_schedules_proto) {
+  // This the modified version of PipelineSchedule::FromProto that ignores
+  // extra nodes in the proto.
+  const auto schedule_it =
+      package_schedules_proto.schedules().find(function->name());
+  if (schedule_it == package_schedules_proto.schedules().end()) {
+    return absl::InvalidArgumentError("Function does not have a schedule.");
+  }
+  ScheduleCycleMap cycle_map;
+  for (const auto& stage : schedule_it->second.stages()) {
+    for (const auto& timed_node : stage.timed_nodes()) {
+      // check if function has node
+      if (function->GetNode(timed_node.node()).ok()) {
+        XLS_ASSIGN_OR_RETURN(Node * node, function->GetNode(timed_node.node()));
+        cycle_map[node] = stage.stage();
+      }
+    }
+  }
+  std::optional<int64_t> min_clock_period_ps;
+  if (schedule_it->second.has_min_clock_period_ps()) {
+    min_clock_period_ps = schedule_it->second.min_clock_period_ps();
+  }
+  return PipelineSchedule(function, cycle_map, /*length=*/std::nullopt,
+                          min_clock_period_ps);
+}
+static absl::Status RealMain(
+    const std::string& ir_path, const std::string& patch_path,
+    const std::string& output_path,
+    const std::optional<std::string>& input_schedule_path) {
+  XLS_ASSIGN_OR_RETURN(std::string ir_data, GetFileContents(ir_path));
+  XLS_ASSIGN_OR_RETURN(std::string patch_data, GetFileContents(patch_path));
+  xls_eco::IrPatchProto patch;
+  patch.ParseFromString(patch_data);
+  XLS_ASSIGN_OR_RETURN(std::unique_ptr<Package> package,
+                       Parser::ParsePackage(ir_data));
+  FunctionBase* function_base = package->GetTop().value();
+  std::optional<PipelineSchedule> schedule;
+  PatchIr patch_ir(function_base, patch);
+  XLS_RETURN_IF_ERROR(patch_ir.ApplyPatch());
+  if (absl::GetFlag(FLAGS_input_schedule_path).has_value()) {
+    XLS_ASSIGN_OR_RETURN(PackagePipelineSchedulesProto schedule_proto,
+                         ParseTextProtoFile<PackagePipelineSchedulesProto>(
+                             absl::GetFlag(FLAGS_input_schedule_path).value()));
+    XLS_ASSIGN_OR_RETURN(
+        schedule, PipelineScheduleFromProto(function_base, schedule_proto));
+    XLS_RETURN_IF_ERROR(patch_ir.PatchSchedule(schedule.value()));
+    XLS_RETURN_IF_ERROR(patch_ir.ExportScheduleProto());
+  }
+  auto output_dir = output_path.substr(0, output_path.find_last_of("/\\"));
+  XLS_RETURN_IF_ERROR(!FileExists(output_dir).ok()
+                          ? RecursivelyCreateDir(output_dir)
+                          : absl::OkStatus());
+  XLS_RETURN_IF_ERROR(patch_ir.ExportIr(output_path));
+  return absl::OkStatus();
+}
+}  // namespace xls
+
+int main(int argc, char** argv) {
+  std::vector<std::string_view> positional_args =
+      xls::InitXls(kUsage, argc, argv);
+  return xls::ExitStatus(xls::RealMain(
+      absl::GetFlag(FLAGS_input_ir_path), absl::GetFlag(FLAGS_input_patch_path),
+      absl::GetFlag(FLAGS_output_ir_path),
+      absl::GetFlag(FLAGS_input_schedule_path)));
+}