diff --git a/mlir/include/mlir/Pass/PipelineBase.td b/mlir/include/mlir/Pass/PipelineBase.td
new file mode 100644
index 0000000000000..70c8553bc27e0
--- /dev/null
+++ b/mlir/include/mlir/Pass/PipelineBase.td
@@ -0,0 +1,80 @@
+//===-- PipelineBase.td - Base pipeline definition file -----*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains definitions for defining pipeline registration and other
+// mechanisms.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_PASS_PIPELINEBASE
+#define MLIR_PASS_PIPELINEBASE
+
+include "mlir/Pass/PassBase.td"
+include "mlir/IR/Utils.td"
+
+//===----------------------------------------------------------------------===//
+// Pipeline Elements
+//===----------------------------------------------------------------------===//
+
+// Base class for all pipeline elements
+class PipelineElement;
+
+// Reference to a pass with options
+class PassElement<string passName> : PipelineElement {
+  // The pass to instantiate (must match registered pass argument)
+  string pass = passName;
+  
+  // Options to pass to this pass instance as a list of strings
+  // Format: ["option_name", "option_value", "option_name", "option_value", ...]
+  list<string> options = [];
+}
+
+// Nested pipeline for a different operation type
+class NestedElement<string targetOp> : PipelineElement {
+  // The operation type this nested pipeline targets
+  string operation = targetOp;
+  
+  // Sequence of elements in this nested pipeline
+  list<PipelineElement> elements = [];
+}
+
+// Reference to a pipeline with options
+class PipelineRef<string pipelineName> : PipelineElement {
+  // The pipeline to instantiate
+  string pipeline = pipelineName;
+  
+  // Options to pass to the pipeline as a list of strings
+  list<string> options = [];
+}
+
+//===----------------------------------------------------------------------===//
+// Pipeline Definitions
+//===----------------------------------------------------------------------===//
+
+// Main pipeline definition class
+class Pipeline<string pipelineArg, string targetOp = ""> {
+  // Command line argument for the pipeline
+  string argument = pipelineArg;
+  
+  // Target operation type (empty means any/module-level)
+  string operation = targetOp;
+  
+  // Short summary of the pipeline
+  string summary = "";
+  
+  // Detailed description
+  string description = "";
+  
+  // Pipeline-level options
+  list<Option> options = [];
+  
+  // Sequence of pipeline elements
+  list<PipelineElement> elements = [];
+}
+
+#endif // MLIR_PASS_PIPELINEBASE
\ No newline at end of file
diff --git a/mlir/include/mlir/TableGen/Pipeline.h b/mlir/include/mlir/TableGen/Pipeline.h
new file mode 100644
index 0000000000000..e2a38c2c98cba
--- /dev/null
+++ b/mlir/include/mlir/TableGen/Pipeline.h
@@ -0,0 +1,102 @@
+//===- Pipeline.h - TableGen Pipeline Record Wrapper ----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the Pipeline class, which is a wrapper around a TableGen
+// Record representing a Pipeline.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TABLEGEN_PIPELINE_H_
+#define MLIR_TABLEGEN_PIPELINE_H_
+
+#include "mlir/TableGen/Pass.h"
+#include "llvm/ADT/StringRef.h"
+#include <vector>
+
+namespace llvm {
+class DagInit;
+class Init;
+class ListInit;
+class Record;
+} // namespace llvm
+
+namespace mlir {
+namespace tblgen {
+
+/// Wrapper class around a TableGen Pipeline record.
+class Pipeline {
+public:
+  explicit Pipeline(const llvm::Record *def);
+
+  /// Get the command line argument for this pipeline.
+  llvm::StringRef getArgument() const;
+
+  /// Get the target operation for this pipeline.
+  llvm::StringRef getOperation() const;
+
+  /// Get the summary for this pipeline.
+  llvm::StringRef getSummary() const;
+
+  /// Get the description for this pipeline.
+  llvm::StringRef getDescription() const;
+
+  /// Get the pipeline options.
+  std::vector<PassOption> getOptions() const;
+
+  /// Get the pipeline elements as a list.
+  const llvm::ListInit *getElements() const;
+
+  /// Get the underlying TableGen record.
+  const llvm::Record *getDef() const { return def; }
+
+private:
+  /// The TableGen record this pipeline is constructed from.
+  const llvm::Record *def;
+};
+
+/// Wrapper class around a TableGen PipelineElement record.
+class PipelineElement {
+public:
+  explicit PipelineElement(const llvm::Init *init);
+
+  /// Check if this is a pass element.
+  bool isPassElement() const;
+
+  /// Check if this is a nested element.
+  bool isNestedElement() const;
+
+  /// Check if this is a pipeline reference element.
+  bool isPipelineElement() const;
+
+  /// Get the pass name (for PassElement).
+  llvm::StringRef getPassName() const;
+
+  /// Get the target operation (for NestedElement).
+  llvm::StringRef getOperation() const;
+
+  /// Get the pipeline name (for PipelineElement).
+  llvm::StringRef getPipelineName() const;
+
+  /// Get the nested elements (for NestedElement).
+  const llvm::ListInit *getElements() const;
+
+  /// Get the options list.
+  const llvm::ListInit *getOptions() const;
+
+  /// Get the underlying TableGen record.
+  const llvm::Record *getDef() const { return def; }
+
+private:
+  /// The TableGen record this element is constructed from.
+  const llvm::Record *def;
+};
+
+} // namespace tblgen
+} // namespace mlir
+
+#endif // MLIR_TABLEGEN_PIPELINE_H_
\ No newline at end of file
diff --git a/mlir/lib/TableGen/CMakeLists.txt b/mlir/lib/TableGen/CMakeLists.txt
index a90c55847718e..df4c4a7bf2090 100644
--- a/mlir/lib/TableGen/CMakeLists.txt
+++ b/mlir/lib/TableGen/CMakeLists.txt
@@ -27,6 +27,7 @@ llvm_add_library(MLIRTableGen STATIC
   Operator.cpp
   Pass.cpp
   Pattern.cpp
+  Pipeline.cpp
   Predicate.cpp
   Property.cpp
   Region.cpp
diff --git a/mlir/lib/TableGen/Pipeline.cpp b/mlir/lib/TableGen/Pipeline.cpp
new file mode 100644
index 0000000000000..91dc3ea365241
--- /dev/null
+++ b/mlir/lib/TableGen/Pipeline.cpp
@@ -0,0 +1,101 @@
+//===- Pipeline.cpp - TableGen Pipeline Record Wrapper ------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the Pipeline class implementation.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/TableGen/Pipeline.h"
+#include "llvm/TableGen/Record.h"
+
+using namespace llvm;
+
+using namespace mlir::tblgen;
+
+//===----------------------------------------------------------------------===//
+// Pipeline
+//===----------------------------------------------------------------------===//
+
+Pipeline::Pipeline(const llvm::Record *def) : def(def) {
+  assert(def->isSubClassOf("Pipeline") && 
+         "must be subclass of 'Pipeline'");
+}
+
+llvm::StringRef Pipeline::getArgument() const {
+  return def->getValueAsString("argument");
+}
+
+llvm::StringRef Pipeline::getOperation() const {
+  return def->getValueAsString("operation");
+}
+
+llvm::StringRef Pipeline::getSummary() const {
+  return def->getValueAsString("summary");
+}
+
+llvm::StringRef Pipeline::getDescription() const {
+  return def->getValueAsString("description");
+}
+
+std::vector<PassOption> Pipeline::getOptions() const {
+  auto *listInit = def->getValueAsListInit("options");
+  std::vector<PassOption> options;
+  for (const auto *optionInit : *listInit) {
+    auto *optionDef = cast<DefInit>(optionInit)->getDef();
+    options.emplace_back(optionDef);
+  }
+  return options;
+}
+
+const llvm::ListInit *Pipeline::getElements() const {
+  return def->getValueAsListInit("elements");
+}
+
+//===----------------------------------------------------------------------===//
+// PipelineElement
+//===----------------------------------------------------------------------===//
+
+PipelineElement::PipelineElement(const llvm::Init *init) {
+  def = cast<DefInit>(init)->getDef();
+}
+
+bool PipelineElement::isPassElement() const {
+  return def->isSubClassOf("PassElement");
+}
+
+bool PipelineElement::isNestedElement() const {
+  return def->isSubClassOf("NestedElement");
+}
+
+bool PipelineElement::isPipelineElement() const {
+  return def->isSubClassOf("PipelineRef");
+}
+
+llvm::StringRef PipelineElement::getPassName() const {
+  assert(isPassElement() && "not a PassElement");
+  return def->getValueAsString("pass");
+}
+
+llvm::StringRef PipelineElement::getOperation() const {
+  assert(isNestedElement() && "not a NestedElement");
+  return def->getValueAsString("operation");
+}
+
+llvm::StringRef PipelineElement::getPipelineName() const {
+  assert(isPipelineElement() && "not a PipelineElement");
+  return def->getValueAsString("pipeline");
+}
+
+const llvm::ListInit *PipelineElement::getElements() const {
+  assert(isNestedElement() && "not a NestedElement");
+  return def->getValueAsListInit("elements");
+}
+
+const llvm::ListInit *PipelineElement::getOptions() const {
+  return def->getValueAsListInit("options");
+}
\ No newline at end of file
diff --git a/mlir/test/mlir-tblgen/gen-pipeline-decls.td b/mlir/test/mlir-tblgen/gen-pipeline-decls.td
new file mode 100644
index 0000000000000..e71c6ce2aaacd
--- /dev/null
+++ b/mlir/test/mlir-tblgen/gen-pipeline-decls.td
@@ -0,0 +1,29 @@
+// RUN: mlir-tblgen -gen-pipeline-decls -I %S/../../include -name Test %s | FileCheck %s
+
+include "mlir/Pass/PipelineBase.td"
+
+// CHECK: namespace mlir {
+
+def SimpleOptimize : Pipeline<"simple-opt", "func.func"> {
+  let summary = "Simple optimization pipeline";
+  let description = "Basic canonicalization and CSE";
+  
+  let options = [
+    Option<"level", "level", "int", "1", "Optimization level">
+  ];
+  
+  let elements = [
+    PassElement<"canonicalize">,
+    PassElement<"cse">
+  ];
+}
+
+// CHECK: struct SimpleOptimizeOptions {
+// CHECK:   int level = 1;
+// CHECK: };
+
+// CHECK: void buildSimpleOptimizePipeline(::mlir::OpPassManager &pm, const SimpleOptimizeOptions &options);
+
+// CHECK: void registerTestPipelines();
+
+// CHECK: } // namespace mlir
\ No newline at end of file
diff --git a/mlir/test/mlir-tblgen/gen-pipeline-doc.td b/mlir/test/mlir-tblgen/gen-pipeline-doc.td
new file mode 100644
index 0000000000000..891c5380fa35e
--- /dev/null
+++ b/mlir/test/mlir-tblgen/gen-pipeline-doc.td
@@ -0,0 +1,32 @@
+// RUN: mlir-tblgen -gen-pipeline-doc -I %S/../../include %s | FileCheck %s
+
+include "mlir/Pass/PipelineBase.td"
+
+def OptimizePipeline : Pipeline<"optimize", "builtin.module"> {
+  let summary = "Full optimization pipeline";
+  let description = [{
+    Comprehensive optimization including canonicalization, inlining, and cleanup.
+  }];
+  
+  let options = [
+    Option<"enableInlining", "enable-inlining", "bool", "true", "Enable inlining">
+  ];
+  
+  let elements = [
+    PassElement<"canonicalize">,
+    PassElement<"inline">,
+    PassElement<"symbol-dce">
+  ];
+}
+
+// CHECK: # Generated Pipeline Documentation
+
+// CHECK: ## optimize
+
+// CHECK: Full optimization pipeline
+
+// CHECK: Comprehensive optimization including canonicalization, inlining, and cleanup.
+
+// CHECK: ### Options
+
+// CHECK: - `--enable-inlining`: Enable inlining
\ No newline at end of file
diff --git a/mlir/test/mlir-tblgen/pipelines-test.td b/mlir/test/mlir-tblgen/pipelines-test.td
new file mode 100644
index 0000000000000..e6e95390c2f0d
--- /dev/null
+++ b/mlir/test/mlir-tblgen/pipelines-test.td
@@ -0,0 +1,107 @@
+//===- pipelines-test.td - Test pipeline definitions -------*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.  
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains test pipeline definitions for the pipeline generation
+// system.
+//
+//===----------------------------------------------------------------------===//
+
+include "mlir/Pass/PipelineBase.td"
+
+// Simple function optimization pipeline
+def FuncOptimize : Pipeline<"func-opt", "func.func"> {
+  let summary = "Standard function-level optimizations";
+  let description = [{
+    Applies canonicalization, CSE, and other function-level optimizations.
+  }];
+  
+  let options = [
+    Option<"maxIterations", "max-iter", "int", "3", 
+           "Maximum number of canonicalization iterations">
+  ];
+  
+  let elements = [
+    PassElement<"canonicalize"> {
+      let options = (ins "max-iterations", "$maxIterations");
+    },
+    PassElement<"cse">,
+    PassElement<"sccp">
+  ];
+}
+
+// Main optimization pipeline
+def OptimizationPipeline : Pipeline<"optimize", "builtin.module"> {
+  let summary = "Full program optimization pipeline";
+  let description = [{
+    Comprehensive optimization pipeline including function-level optimizations,
+    inlining, and symbol cleanup.
+  }];
+  
+  let options = [
+    Option<"enableInlining", "enable-inlining", "bool", "true",
+           "Enable aggressive inlining">,
+    Option<"funcOptLevel", "func-opt-level", "int", "2",
+           "Function optimization level">
+  ];
+  
+  let elements = [
+    // Apply function optimizations
+    NestedElement<"func.func"> {
+      let elements = [
+        PipelineRef<"func-opt"> {
+          let options = (ins "max-iter", "$funcOptLevel");
+        }
+      ];
+    },
+    
+    // Module-level passes
+    PassElement<"symbol-dce">,
+    
+    // Conditional inlining
+    PassElement<"inline"> {
+      let options = (ins "default-pipeline", "");
+    },
+    
+    // Re-run function opts after inlining
+    NestedElement<"func.func"> {
+      let elements = [
+        PipelineRef<"func-opt"> {
+          let options = (ins "max-iter", "1");
+        }
+      ];
+    }
+  ];
+}
+
+// GPU-specific pipeline
+def GPUPipeline : Pipeline<"gpu-opt", "builtin.module"> {
+  let summary = "GPU-specific optimization pipeline";
+  
+  let options = [
+    Option<"targetGPU", "target", "string", "\"generic\"",
+           "Target GPU architecture">
+  ];
+  
+  let elements = [
+    NestedElement<"gpu.module"> {
+      let elements = [
+        PassElement<"gpu-kernel-outlining">,
+        NestedElement<"func.func"> {
+          let elements = [
+            PassElement<"canonicalize">,
+            PassElement<"gpu-launch-sink-index-computations">
+          ];
+        }
+      ];
+    },
+    PassElement<"gpu-async-region">,
+    PassElement<"convert-gpu-to-nvvm"> {
+      let options = (ins "index-bitwidth", "64");
+    }
+  ];
+}
\ No newline at end of file
diff --git a/mlir/tools/mlir-tblgen/CMakeLists.txt b/mlir/tools/mlir-tblgen/CMakeLists.txt
index 2a7ef7e0576c8..518652cd80b27 100644
--- a/mlir/tools/mlir-tblgen/CMakeLists.txt
+++ b/mlir/tools/mlir-tblgen/CMakeLists.txt
@@ -30,6 +30,7 @@ add_tablegen(mlir-tblgen MLIR
   PassCAPIGen.cpp
   PassDocGen.cpp
   PassGen.cpp
+  PipelineGen.cpp
   RewriterGen.cpp
   SPIRVUtilsGen.cpp
   TosaUtilsGen.cpp
diff --git a/mlir/tools/mlir-tblgen/PipelineGen-fixed.cpp b/mlir/tools/mlir-tblgen/PipelineGen-fixed.cpp
new file mode 100644
index 0000000000000..ca5ea5acf1754
--- /dev/null
+++ b/mlir/tools/mlir-tblgen/PipelineGen-fixed.cpp
@@ -0,0 +1,46 @@
+// Simplified version of emitPipelineElement function
+static void emitPipelineElement(const PipelineElement &element,
+                                const PipelineDef &pipeline,
+                                llvm::raw_ostream &os,
+                                int indent = 2) {
+  std::string indentStr(indent, ' ');
+
+  if (element.isPassElement()) {
+    StringRef passName = element.getPassName();
+    os << indentStr << "// Add pass: " << passName << "\n";
+    
+    // For now, just generate simple passes without options
+    // TODO: Add option handling support for list<string> options
+    os << indentStr << "pm.addPass(mlir::create" 
+       << llvm::convertToCamelFromSnakeCase(passName, true) 
+       << "Pass());\n";
+       
+  } else if (element.isNestedElement()) {
+    StringRef opType = element.getOperation();
+    os << indentStr << "// Nested pipeline for " << opType << "\n";
+    os << indentStr << "{\n";
+    os << indentStr << "  auto nestedPM = pm.nest<" << opType << ">();\n";
+    
+    // Process nested elements
+    const llvm::ListInit *elements = element.getElements();
+    for (const auto *elemInit : *elements) {
+      PipelineElement nestedElem(elemInit);
+      emitPipelineElement(nestedElem, pipeline, os, indent + 2);
+    }
+    
+    os << indentStr << "}\n";
+    
+  } else if (element.isPipelineElement()) {
+    StringRef pipelineName = element.getPipelineName();
+    os << indentStr << "// Add pipeline: " << pipelineName << "\n";
+    
+    // For now, just generate simple pipeline calls
+    // TODO: Add option handling support
+    std::string emptyOptionsStruct = pipelineName.str() + "Options{}";
+    os << indentStr << "build" 
+       << llvm::convertToCamelFromSnakeCase(pipelineName, true)
+       << "Pipeline(pm, " << emptyOptionsStruct << ");\n";
+  }
+  
+  os << "\n";
+}
\ No newline at end of file
diff --git a/mlir/tools/mlir-tblgen/PipelineGen.cpp b/mlir/tools/mlir-tblgen/PipelineGen.cpp
new file mode 100644
index 0000000000000..077cffc59660f
--- /dev/null
+++ b/mlir/tools/mlir-tblgen/PipelineGen.cpp
@@ -0,0 +1,385 @@
+//===- PipelineGen.cpp - MLIR pipeline registration generator -------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// PipelineGen uses the description of pipelines to generate pipeline
+// registration and builder functions.
+//
+//===----------------------------------------------------------------------===//
+
+#include "PipelineGen.h"
+#include "mlir/TableGen/GenInfo.h"
+#include "mlir/TableGen/Pass.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+
+using namespace mlir;
+using namespace mlir::tblgen;
+using llvm::formatv;
+using llvm::RecordKeeper;
+
+static llvm::cl::OptionCategory pipelineGenCat("Options for -gen-pipeline-*");
+static llvm::cl::opt<std::string>
+    groupName("pipelineGroupName", llvm::cl::desc("The name of this group of pipelines"),
+              llvm::cl::cat(pipelineGenCat));
+
+namespace {
+/// Wrapper class around a pipeline definition record.
+class PipelineDef {
+public:
+  explicit PipelineDef(const llvm::Record *def) : def(def) {}
+
+  /// Get the command line argument for this pipeline.
+  StringRef getArgument() const { return def->getValueAsString("argument"); }
+
+  /// Get the target operation for this pipeline.
+  StringRef getOperation() const { return def->getValueAsString("operation"); }
+
+  /// Get the summary for this pipeline.
+  StringRef getSummary() const { return def->getValueAsString("summary"); }
+
+  /// Get the description for this pipeline.
+  StringRef getDescription() const {
+    return def->getValueAsString("description");
+  }
+
+  /// Get the pipeline options.
+  std::vector<PassOption> getOptions() const {
+    auto *listInit = def->getValueAsListInit("options");
+    std::vector<PassOption> options;
+    for (const auto *optionInit : *listInit) {
+      auto *optionDef = llvm::cast<llvm::DefInit>(optionInit)->getDef();
+      options.emplace_back(optionDef);
+    }
+    return options;
+  }
+
+  /// Get the pipeline elements.
+  const llvm::ListInit *getElements() const {
+    return def->getValueAsListInit("elements");
+  }
+
+  /// Get the underlying record.
+  const llvm::Record *getDef() const { return def; }
+
+private:
+  const llvm::Record *def;
+};
+
+/// Wrapper class around a pipeline element record.
+class PipelineElement {
+public:
+  explicit PipelineElement(const llvm::Init *init) {
+    def = llvm::cast<llvm::DefInit>(init)->getDef();
+  }
+
+  /// Check if this is a pass element.
+  bool isPassElement() const {
+    return def->isSubClassOf("PassElement");
+  }
+
+  /// Check if this is a nested element.
+  bool isNestedElement() const {
+    return def->isSubClassOf("NestedElement");
+  }
+
+  /// Check if this is a pipeline reference element.
+  bool isPipelineElement() const {
+    return def->isSubClassOf("PipelineRef");
+  }
+
+  /// Get the pass name (for PassElement).
+  StringRef getPassName() const {
+    return def->getValueAsString("pass");
+  }
+
+  /// Get the target operation (for NestedElement).
+  StringRef getOperation() const {
+    return def->getValueAsString("operation");
+  }
+
+  /// Get the pipeline name (for PipelineElement).
+  StringRef getPipelineName() const {
+    return def->getValueAsString("pipeline");
+  }
+
+  /// Get the nested elements (for NestedElement).
+  const llvm::ListInit *getElements() const {
+    return def->getValueAsListInit("elements");
+  }
+
+  /// Get the options as a list of strings.
+  const llvm::ListInit *getOptions() const {
+    return def->getValueAsListInit("options");
+  }
+
+private:
+  const llvm::Record *def;
+};
+} // namespace
+
+/// Extract the list of pipelines from the TableGen records.
+static std::vector<PipelineDef> getPipelines(const RecordKeeper &records) {
+  std::vector<PipelineDef> pipelines;
+
+  for (const auto *def : records.getAllDerivedDefinitions("Pipeline"))
+    pipelines.emplace_back(def);
+
+  return pipelines;
+}
+
+const char *const pipelineHeader = R"(
+//===----------------------------------------------------------------------===//
+// {0}
+//===----------------------------------------------------------------------===//
+)";
+
+/// Generate the options struct for a pipeline.
+static void emitPipelineOptionsStruct(const PipelineDef &pipeline,
+                                      llvm::raw_ostream &os) {
+  StringRef pipelineName = pipeline.getDef()->getName();
+  auto options = pipeline.getOptions();
+
+  // Emit the struct only if the pipeline has at least one option.
+  if (options.empty())
+    return;
+
+  os << formatv("struct {0}Options {{\n", pipelineName);
+
+  for (const PassOption &opt : options) {
+    std::string type = opt.getType().str();
+
+    if (opt.isListOption())
+      type = "::llvm::SmallVector<" + type + ">";
+
+    os.indent(2) << formatv("{0} {1}", type, opt.getCppVariableName());
+
+    if (std::optional<StringRef> defaultVal = opt.getDefaultValue())
+      os << " = " << defaultVal;
+
+    os << ";\n";
+  }
+
+  os << "};\n\n";
+}
+
+/// Generate code for a single pipeline element.
+static void emitPipelineElement(const PipelineElement &element,
+                                const PipelineDef &pipeline,
+                                llvm::raw_ostream &os,
+                                int indent = 2) {
+  std::string indentStr(indent, ' ');
+
+  if (element.isPassElement()) {
+    StringRef passName = element.getPassName();
+    os << indentStr << "// Add pass: " << passName << "\n";
+    
+    // For now, just generate simple passes without options
+    // TODO: Add option handling support for list<string> options
+    os << indentStr << "pm.addPass(mlir::create" 
+       << llvm::convertToCamelFromSnakeCase(passName, true) 
+       << "Pass());\n";
+       
+  } else if (element.isNestedElement()) {
+    StringRef opType = element.getOperation();
+    os << indentStr << "// Nested pipeline for " << opType << "\n";
+    os << indentStr << "{\n";
+    os << indentStr << "  auto nestedPM = pm.nest<" << opType << ">();\n";
+    
+    // Process nested elements
+    const llvm::ListInit *elements = element.getElements();
+    for (const auto *elemInit : *elements) {
+      PipelineElement nestedElem(elemInit);
+      emitPipelineElement(nestedElem, pipeline, os, indent + 2);
+    }
+    
+    os << indentStr << "}\n";
+    
+  } else if (element.isPipelineElement()) {
+    StringRef pipelineName = element.getPipelineName();
+    os << indentStr << "// Add pipeline: " << pipelineName << "\n";
+    
+    // For now, just generate simple pipeline calls
+    // TODO: Add option handling support
+    std::string emptyOptionsStruct = pipelineName.str() + "Options{}";
+    os << indentStr << "build" 
+       << llvm::convertToCamelFromSnakeCase(pipelineName, true)
+       << "Pipeline(pm, " << emptyOptionsStruct << ");\n";
+  }
+  
+  os << "\n";
+}
+
+/// Generate the builder function for a pipeline.
+static void emitPipelineBuilder(const PipelineDef &pipeline,
+                                llvm::raw_ostream &os) {
+  StringRef pipelineName = pipeline.getDef()->getName();
+  auto options = pipeline.getOptions();
+
+  os << "void build"
+     << llvm::convertToCamelFromSnakeCase(pipelineName, true)
+     << "Pipeline(::mlir::OpPassManager &pm";
+
+  if (!options.empty()) {
+    os << ", const " << pipelineName << "Options &options";
+  }
+
+  os << ") {\n";
+
+  // Process pipeline elements
+  const llvm::ListInit *elements = pipeline.getElements();
+  for (const auto *elemInit : *elements) {
+    PipelineElement element(elemInit);
+    emitPipelineElement(element, pipeline, os);
+  }
+
+  os << "}\n\n";
+}
+
+/// Generate the registration code for all pipelines.
+static void emitPipelineRegistrations(llvm::ArrayRef<PipelineDef> pipelines,
+                                      llvm::raw_ostream &os,
+                                      StringRef groupName) {
+  os << "void register" << groupName << "Pipelines() {\n";
+
+  for (const auto &pipeline : pipelines) {
+    StringRef pipelineName = pipeline.getDef()->getName();
+    StringRef argument = pipeline.getArgument();
+    StringRef summary = pipeline.getSummary();
+    auto options = pipeline.getOptions();
+
+    if (!options.empty()) {
+      os << "  ::mlir::PassPipelineRegistration<" << pipelineName << "Options>(\n";
+    } else {
+      os << "  ::mlir::PassPipelineRegistration<>(\n";
+    }
+
+    os << "    \"" << argument << "\",\n";
+    os << "    \"" << summary << "\",\n";
+    os << "    build"
+       << llvm::convertToCamelFromSnakeCase(pipelineName, true)
+       << "Pipeline);\n\n";
+  }
+
+  os << "}\n\n";
+}
+
+void mlir::emitPipelineDecls(const RecordKeeper &recordKeeper,
+                             llvm::raw_ostream &os, StringRef groupName) {
+  std::vector<PipelineDef> pipelines = getPipelines(recordKeeper);
+  if (pipelines.empty())
+    return;
+
+  os << formatv(pipelineHeader, groupName + " Pipeline Declarations");
+
+  os << "namespace mlir {\n\n";
+
+  // Emit pipeline options structs
+  for (const auto &pipeline : pipelines) {
+    emitPipelineOptionsStruct(pipeline, os);
+  }
+
+  // Emit pipeline builder function declarations
+  for (const auto &pipeline : pipelines) {
+    StringRef pipelineName = pipeline.getDef()->getName();
+    auto options = pipeline.getOptions();
+
+    os << "void build"
+       << llvm::convertToCamelFromSnakeCase(pipelineName, true)
+       << "Pipeline(::mlir::OpPassManager &pm";
+
+    if (!options.empty()) {
+      os << ", const " << pipelineName << "Options &options";
+    }
+
+    os << ");\n";
+  }
+
+  os << "\n";
+
+  // Emit registration function declaration
+  os << "void register" << groupName << "Pipelines();\n\n";
+
+  os << "} // namespace mlir\n";
+}
+
+void mlir::emitPipelineImpls(const RecordKeeper &recordKeeper,
+                             llvm::raw_ostream &os, StringRef groupName) {
+  std::vector<PipelineDef> pipelines = getPipelines(recordKeeper);
+  if (pipelines.empty())
+    return;
+
+  os << formatv(pipelineHeader, groupName + " Pipeline Implementations");
+
+  os << "namespace mlir {\n\n";
+
+  // Emit pipeline builder functions
+  for (const auto &pipeline : pipelines) {
+    emitPipelineBuilder(pipeline, os);
+  }
+
+  // Emit registration function
+  emitPipelineRegistrations(pipelines, os, groupName);
+
+  os << "} // namespace mlir\n";
+}
+
+void mlir::emitPipelineDoc(const RecordKeeper &recordKeeper,
+                           llvm::raw_ostream &os) {
+  std::vector<PipelineDef> pipelines = getPipelines(recordKeeper);
+  if (pipelines.empty())
+    return;
+
+  os << "# Generated Pipeline Documentation\n\n";
+
+  for (const auto &pipeline : pipelines) {
+    os << "## " << pipeline.getArgument() << "\n\n";
+
+    if (!pipeline.getSummary().empty()) {
+      os << pipeline.getSummary() << "\n\n";
+    }
+
+    if (!pipeline.getDescription().empty()) {
+      os << pipeline.getDescription() << "\n\n";
+    }
+
+    auto options = pipeline.getOptions();
+    if (!options.empty()) {
+      os << "### Options\n\n";
+      for (const auto &option : options) {
+        os << "- `--" << option.getArgument() << "`: "
+           << option.getDescription() << "\n";
+      }
+      os << "\n";
+    }
+  }
+}
+
+// Register the generators
+static mlir::GenRegistration genPipelineDecls(
+    "gen-pipeline-decls", "Generate pipeline declarations",
+    [](const RecordKeeper &records, llvm::raw_ostream &os) {
+      mlir::emitPipelineDecls(records, os, groupName);
+      return false;
+    });
+
+static mlir::GenRegistration genPipelineImpls(
+    "gen-pipeline-impls", "Generate pipeline implementations",
+    [](const RecordKeeper &records, llvm::raw_ostream &os) {
+      mlir::emitPipelineImpls(records, os, groupName);
+      return false;
+    });
+
+static mlir::GenRegistration genPipelineDoc(
+    "gen-pipeline-doc", "Generate pipeline documentation",
+    [](const RecordKeeper &records, llvm::raw_ostream &os) {
+      mlir::emitPipelineDoc(records, os);
+      return false;
+    });
diff --git a/mlir/tools/mlir-tblgen/PipelineGen.h b/mlir/tools/mlir-tblgen/PipelineGen.h
new file mode 100644
index 0000000000000..4030ff5a6c0cb
--- /dev/null
+++ b/mlir/tools/mlir-tblgen/PipelineGen.h
@@ -0,0 +1,39 @@
+//===- PipelineGen.h - MLIR pipeline registration generator ----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// PipelineGen uses the description of pipelines to generate pipeline
+// registration and builder functions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TOOLS_MLIR_TBLGEN_PIPELINEGEN_H_
+#define MLIR_TOOLS_MLIR_TBLGEN_PIPELINEGEN_H_
+
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+class RecordKeeper;
+}
+
+namespace mlir {
+
+/// Emit pipeline declarations.
+void emitPipelineDecls(const llvm::RecordKeeper &recordKeeper,
+                       llvm::raw_ostream &os, llvm::StringRef groupName);
+
+/// Emit pipeline implementations.  
+void emitPipelineImpls(const llvm::RecordKeeper &recordKeeper,
+                       llvm::raw_ostream &os, llvm::StringRef groupName);
+
+/// Emit pipeline documentation.
+void emitPipelineDoc(const llvm::RecordKeeper &recordKeeper,
+                     llvm::raw_ostream &os);
+
+} // namespace mlir
+
+#endif // MLIR_TOOLS_MLIR_TBLGEN_PIPELINEGEN_H_
\ No newline at end of file
diff --git a/mlir/tools/mlir-tblgen/mlir-tblgen.cpp b/mlir/tools/mlir-tblgen/mlir-tblgen.cpp
index 6c4b619598eb6..918ce70cbe2cd 100644
--- a/mlir/tools/mlir-tblgen/mlir-tblgen.cpp
+++ b/mlir/tools/mlir-tblgen/mlir-tblgen.cpp
@@ -12,6 +12,7 @@
 
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/Tools/mlir-tblgen/MlirTblgenMain.h"
+#include "PipelineGen.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace llvm;