diff --git a/src/Algorithm/IpAlgBuilder.cpp b/src/Algorithm/IpAlgBuilder.cpp
index 8c622c17f..c70e92249 100644
--- a/src/Algorithm/IpAlgBuilder.cpp
+++ b/src/Algorithm/IpAlgBuilder.cpp
@@ -59,6 +59,8 @@
 #include "IpMa97SolverInterface.hpp"
 #include "IpMc19TSymScalingMethod.hpp"
 #include "IpPardisoSolverInterface.hpp"
+// TODO Implement IPOPT_HAS_LEOPARD
+#include "IpLeopardSolverInterface.hpp"
 #ifdef IPOPT_HAS_PARDISO_MKL
 # include "IpPardisoMKLSolverInterface.hpp"
 #endif
@@ -183,6 +185,12 @@ void AlgorithmBuilder::RegisterOptions(
       descrs.push_back("use the Pardiso package from Intel MKL");
    }
 
+   if( availablesolvers & IPOPTLINEARSOLVER_LEOPARD )
+   {
+      options.push_back("leopard");
+      descrs.push_back("use Leopard");
+   }
+
    if( availablesolvers & IPOPTLINEARSOLVER_SPRAL )
    {
       options.push_back("spral");
@@ -241,6 +249,10 @@ void AlgorithmBuilder::RegisterOptions(
    {
       defaultsolver = "pardisomkl";
    }
+   else if( availablesolverslinked & IPOPTLINEARSOLVER_LEOPARD )
+   {
+      defaultsolver = "leopard";
+   }
    else if( availablesolverslinked & IPOPTLINEARSOLVER_MA77 )
    {
       defaultsolver = "ma77";
@@ -468,6 +480,12 @@ SmartPtr<SymLinearSolver> AlgorithmBuilder::SymLinearSolverFactory(
    }
 #endif
 
+   // TODO Implement IPOPT_HAS_LEOPARD
+   else if( linear_solver == "leopard" )
+   {
+      SolverInterface = new LeopardSolverInterface();
+   }
+
 #ifdef IPOPT_HAS_PARDISO_MKL
    else if( linear_solver == "pardisomkl" )
    {
diff --git a/src/Algorithm/LinearSolvers/IpLeopardSolverInterface.cpp b/src/Algorithm/LinearSolvers/IpLeopardSolverInterface.cpp
new file mode 100644
index 000000000..efd5ff30d
--- /dev/null
+++ b/src/Algorithm/LinearSolvers/IpLeopardSolverInterface.cpp
@@ -0,0 +1,296 @@
+// Copyright (C) 2005, 2006 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors:  Morten Lysgaard               2023-09-19
+//               original version (based on MA57TSolverInterface.hpp)
+
+#include "IpoptConfig.h"
+#include "IpLeopardSolverInterface.hpp"
+
+#include <cmath>
+#include <iostream>
+
+namespace Ipopt {
+#if IPOPT_VERBOSITY > 0
+static const Index dbg_verbosity = 0;
+#endif
+
+LeopardSolverInterface::LeopardSolverInterface(
+) :
+    dim_(0),
+    nonzeros_(0),
+    initialized_(false),
+    pivtol_changed_(false),
+    refactorize_(false) {
+  DBG_START_METH("LeopardSolverInterface::LeopardSolverInterface()", dbg_verbosity);
+}
+
+LeopardSolverInterface::~LeopardSolverInterface() {
+  DBG_START_METH("LeopardSolverInterface::~LeopardSolverInterface()", dbg_verbosity);
+}
+
+void LeopardSolverInterface::RegisterOptions(
+    SmartPtr<RegisteredOptions> roptions
+) {
+   roptions->AddBoundedNumberOption(
+      "leopard_pivtol",
+      "Pivot tolerance for the Leopard linear solver.",
+      0.0, true,
+      0.5, true,
+      1e-8,
+      "A smaller number pivots for sparsity, a larger number pivots for stability.");
+   roptions->AddBoundedNumberOption(
+      "leopard_pivtolmax",
+      "Maximum pivot tolerance for the Leopard linear solver.",
+      0.0, true,
+      0.5, true,
+      1e-4,
+      "Ipopt may increase pivtol as high as leopard_pivtolmax to get a more accurate solution to the linear system.");
+}
+
+bool LeopardSolverInterface::InitializeImpl(
+    const OptionsList &options,
+    const std::string &prefix
+) {
+  options.GetNumericValue("leopard_pivtol", pivtol_, prefix);
+  if( options.GetNumericValue("leopard_pivtolmax", pivtolmax_, prefix) )
+  {
+     ASSERT_EXCEPTION(pivtolmax_ >= pivtol_, OPTION_INVALID, "Option \"leopard_pivtolmax\": This value must be between "
+                      "leopard_pivtol and 0.5.");
+  }
+  else
+  {
+     pivtolmax_ = Max(pivtolmax_, pivtol_);
+  }
+
+  // Reset all private data
+  initialized_ = false;
+  pivtol_changed_ = false;
+  refactorize_ = false;
+
+  factorization_settings_ = leopard_factorization_settings_new_default_f64();
+
+  return true;
+}
+
+ESymSolverStatus LeopardSolverInterface::MultiSolve(
+    bool new_matrix,
+    const Index *ia,
+    const Index *ja,
+    Index nrhs,
+    Number *rhs_vals,
+    bool check_NegEVals,
+    Index numberOfNegEVals
+) {
+  DBG_START_METH("LeopardSolverInterface::MultiSolve", dbg_verbosity);
+   DBG_ASSERT(!check_NegEVals || ProvidesInertia());
+   DBG_ASSERT(initialized_);
+
+   if(pivtol_changed_)
+   {
+      DBG_PRINT((1, "Pivot tolerance has changed.\n"));
+      pivtol_changed_ = false;
+      // If the pivot tolerance has been changed but the matrix is not
+      // new, we have to request the values for the matrix again to do
+      // the factorization again.
+      if( !new_matrix )
+      {
+         DBG_PRINT((1, "Ask caller to call again.\n"));
+         refactorize_ = true;
+         return SYMSOLVER_CALL_AGAIN;
+      }
+   }
+
+   // check if a factorization has to be done
+   DBG_PRINT((1, "new_matrix = %d\n", new_matrix));
+   if( new_matrix || refactorize_ )
+   {
+      // perform the factorization
+      ESymSolverStatus retval;
+      retval = Factorization(ia, ja, check_NegEVals, numberOfNegEVals);
+      if( retval != SYMSOLVER_SUCCESS )
+      {
+         DBG_PRINT((1, "FACTORIZATION FAILED!\n"));
+         return retval;  // Matrix singular or error occurred
+      }
+      refactorize_ = false;
+   }
+
+   // do the solve
+  return Backsolve(nrhs, rhs_vals);
+}
+
+Number *LeopardSolverInterface::GetValuesArrayPtr() {
+  DBG_START_METH("LeopardSolverInterface::GetValuesArrayPtr", dbg_verbosity);
+  DBG_ASSERT(initialized_);
+  DBG_ASSERT(a_);
+
+  return a_;
+}
+
+/** Initialize the local copy of the positions of the nonzero elements */
+ESymSolverStatus LeopardSolverInterface::InitializeStructure(
+    Index dim,
+    Index nonzeros,
+    const Index *ia,
+    const Index *ja
+) {
+  DBG_START_METH("LeopardSolverInterface::InitializeStructure", dbg_verbosity);
+  dim_ = dim;
+  nonzeros_ = nonzeros;
+
+  // Make space for storing the matrix elements
+  if(!a_){
+    delete[] a_;
+  }
+  a_ = NULL;
+  a_ = new Number[nonzeros_];
+
+  // Do the symbolic facotrization
+  ESymSolverStatus retval = SymbolicFactorization(ia, ja);
+  if( retval != SYMSOLVER_SUCCESS )
+  {
+     return retval;
+  }
+
+  initialized_ = true;
+
+  return retval;
+}
+
+ESymSolverStatus LeopardSolverInterface::SymbolicFactorization(
+    const Index *airn,
+    const Index *ajcn
+) {
+  DBG_START_METH("LeopardSolverInterface::SymbolicFactorization", dbg_verbosity);
+
+#ifdef IPOPT_INT64
+  ij_ = leopard_ij_new_csr_array_i64(dim_, nonzeros_, airn, ajcn, true);
+#else
+  ij_ = leopard_ij_new_csr_array_i32(dim_, nonzeros_, airn, ajcn, true);
+#endif
+  if(ij_.code != LeopardReturnCode_Ok){
+    printf("LeopardSolverInterface::SymbolicFactorization::ERROR: %s\n", leopard_explain_return_code(ij_.code));
+    return SYMSOLVER_FATAL_ERROR;
+  }
+  DBG_ASSERT(ij_.object!=nullptr);
+
+  ordering_ = leopard_ordering_new_amd_default(ij_.object);
+  if(ordering_.code != LeopardReturnCode_Ok){
+    printf("LeopardSolverInterface::SymbolicFactorization::ERROR: %s\n", leopard_explain_return_code(ordering_.code));
+    return SYMSOLVER_FATAL_ERROR;
+  }
+  DBG_ASSERT(ordering_.object!=nullptr);
+
+  ordered_ij_ = leopard_ordered_ij_new(ij_.object, ordering_.object);
+  if(ordered_ij_.code != LeopardReturnCode_Ok) {
+    printf("LeopardSolverInterface::SymbolicFactorization::ERROR: %s\n", leopard_explain_return_code(ordered_ij_.code));
+    return SYMSOLVER_FATAL_ERROR;
+  }
+  DBG_ASSERT(ordered_ij_.object!=nullptr);
+
+  assembly_tree_ = leopard_assembly_tree_new(ordered_ij_.object, true);
+  if(assembly_tree_.code != LeopardReturnCode_Ok)
+  {
+    printf("LeopardSolverInterface::SymbolicFactorization::ERROR: %s\n", leopard_explain_return_code(assembly_tree_.code));
+    return SYMSOLVER_FATAL_ERROR;
+  }
+  DBG_ASSERT(assembly_tree_.object!=nullptr);
+
+  return SYMSOLVER_SUCCESS;
+}
+
+ESymSolverStatus LeopardSolverInterface::Factorization(
+    const Index * /*ia*/,
+    const Index * /*ja*/,
+    bool check_NegEVals,
+    Index numberOfNegEVals
+) {
+  DBG_START_METH("LeopardSolverInterface::Factorization", dbg_verbosity);
+
+  DBG_ASSERT(ordered_ij_.object != nullptr);
+  DBG_ASSERT(ordered_ij_.code == OrderedIjReturnCode::Ok);
+  DBG_ASSERT(ordering_.object != nullptr);
+  DBG_ASSERT(ordering_.code == OrderingReturnCode::Ok);
+  DBG_ASSERT(assembly_tree_.object != nullptr);
+  DBG_ASSERT(assembly_tree_.code == AssemblyTreeReturnCode::Ok);
+
+  // Do factorization
+#ifdef IPOPT_SINGLE
+  leopard_factorization_settings_set_pivot_tolerance_f64(factorization_settings_, pivtol_);
+  ldl_factorization_ = leopard_ldl_factorize_f32(ordered_ij_.object, a_, ordering_.object, assembly_tree_.object, factorization_settings_);
+#else
+  leopard_factorization_settings_set_pivot_tolerance_f64(factorization_settings_, pivtol_);
+  ldl_factorization_ = leopard_ldl_factorize_f64(ordered_ij_.object, a_, ordering_.object, assembly_tree_.object, factorization_settings_);
+#endif
+  if(ldl_factorization_.code!=LeopardReturnCode_Ok)
+  {
+    printf("LeopardSolverInterface::Factorization::ERROR: %s\n", leopard_explain_return_code(ldl_factorization_.code));
+    return SYMSOLVER_FATAL_ERROR;
+  }
+  DBG_ASSERT(ldl.object != nullptr);
+
+  // Compute matrix intertia
+#ifdef IPOPT_SINGLE
+  eigenvalue_sign_count_ = leopard_ldl_eigenvalue_sign_count_f32(ldl_factorization_.object);
+#else
+  eigenvalue_sign_count_ = leopard_ldl_eigenvalue_sign_count_f64(ldl_factorization_.object);
+#endif
+
+  // Check if we have correct intertia
+  // TODO: Check if this is corrent way to do it
+  if(check_NegEVals && eigenvalue_sign_count_.negative!=numberOfNegEVals){
+    return SYMSOLVER_WRONG_INERTIA;
+  }
+
+  return SYMSOLVER_SUCCESS;
+}
+
+ESymSolverStatus LeopardSolverInterface::Backsolve(
+    Index nrhs,
+    Number *rhs_vals
+) {
+  DBG_START_METH("LeopardSolverInterface::Backsolve", dbg_verbosity);
+  DBG_ASSERT(ldl_factorization_.object != nullptr);
+  DBG_ASSERT(ldl_factorization_.code == LDLFactorizationReturnCode::Ok);
+
+  // TODO
+  for (int i=0; i<nrhs; i++){
+    Number *cur_rhs = rhs_vals+i*dim_;
+#ifdef IPOPT_SINGLE
+    LeopardReturnCode retval = leopard_ldl_solve_f32(ldl_factorization_.object, cur_rhs);
+#else
+    LeopardReturnCode retval = leopard_ldl_solve_f64(ldl_factorization_.object, cur_rhs);
+#endif
+    if(retval!=LeopardReturnCode_Ok)
+    {
+      return SYMSOLVER_FATAL_ERROR;
+    }
+  }
+  return SYMSOLVER_SUCCESS;
+}
+
+Index LeopardSolverInterface::NumberOfNegEVals() const {
+  DBG_START_METH("LeopardSolverInterface::NumberOfNegEVals", dbg_verbosity);
+  DBG_ASSERT(ProvidesInertia());
+  DBG_ASSERT(initialized_);
+  return eigenvalue_sign_count_.negative;
+}
+
+bool LeopardSolverInterface::IncreaseQuality() {
+  DBG_START_METH("LeopardSolverInterface::IncreaseQuality", dbg_verbosity);
+  if (pivtol_ == pivtolmax_) {
+    return false;
+  }
+  pivtol_changed_ = true;
+
+  Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA,
+                 "Increasing pivot tolerance for Leopard from %7.2e ", pivtol_);
+  pivtol_ = Min(pivtolmax_, std::pow(pivtol_, Number(0.75)));
+  Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA,
+                 "to %7.2e.\n", pivtol_);
+  return true;
+}
+
+} // namespace Ipopt
diff --git a/src/Algorithm/LinearSolvers/IpLeopardSolverInterface.hpp b/src/Algorithm/LinearSolvers/IpLeopardSolverInterface.hpp
new file mode 100644
index 000000000..4278c4172
--- /dev/null
+++ b/src/Algorithm/LinearSolvers/IpLeopardSolverInterface.hpp
@@ -0,0 +1,194 @@
+// Copyright (C) 2005, 2006 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors:  Morten Lysgaard               2023-09-19
+//               original version (based on MA57TSolverInterface.hpp)
+
+#ifndef __IPLEOPARDSOLVERINTERFACE_HPP__
+#define __IPLEOPARDSOLVERINTERFACE_HPP__
+
+#include "IpSparseSymLinearSolverInterface.hpp"
+#include "IpLibraryLoader.hpp"
+#include "IpTypes.h"
+
+#include <leopard.h>
+
+namespace Ipopt {
+/** Interface to the linear symmetric indefinite sparse solver Leopard, derived from
+ *  SparseSymLinearSolverInterface.
+ */
+class LeopardSolverInterface : public SparseSymLinearSolverInterface {
+ public:
+  /** @name Constructor/Destructor */
+  ///@{
+  /** Constructor */
+  LeopardSolverInterface(
+  );
+
+  /** Destructor */
+  ~LeopardSolverInterface() override;
+  ///@}
+
+  bool InitializeImpl(
+      const OptionsList &options,
+      const std::string &prefix
+  ) override;
+
+  /** @name Methods for requesting solution of the linear system. */
+  ///@{
+  ESymSolverStatus InitializeStructure(
+      Index dim,
+      Index nonzeros,
+      const Index *airn,
+      const Index *ajcn
+  ) override;
+
+  Number *GetValuesArrayPtr() override;
+
+  ESymSolverStatus MultiSolve(
+      bool new_matrix,
+      const Index *airn,
+      const Index *ajcn,
+      Index nrhs,
+      Number *rhs_vals,
+      bool check_NegEVals,
+      Index numberOfNegEVals
+  ) override;
+
+  Index NumberOfNegEVals() const override;
+  ///@}
+
+  //* @name Options of Linear solver */
+  ///@{
+  bool IncreaseQuality() override;
+
+  bool ProvidesInertia() const override {
+    return true;
+  }
+
+  EMatrixFormat MatrixFormat() const override {
+    return CSR_Format_0_Offset;
+  }
+  ///@}
+
+  ///@{
+  static void RegisterOptions(
+      SmartPtr<RegisteredOptions> roptions
+  );
+  ///@}
+
+ private:
+  /**@name Default Compiler Generated Methods
+   * (Hidden to avoid implicit creation/calling).
+   * These methods are not implemented and
+   * we do not want the compiler to implement
+   * them for us, so we declare them private
+   * and do not define them. This ensures that
+   * they will not be implicitly created/called. */
+  ///@{
+  /** Copy Constructor */
+  LeopardSolverInterface(
+      const LeopardSolverInterface &
+  ) = delete;
+
+  /** Default Assignment Operator */
+  void operator=(
+      const LeopardSolverInterface &
+  ) = delete;
+  ///@}
+
+  /** @name Information about the matrix */
+  ///@{
+  /** Number of rows and columns of the matrix */
+  Index dim_;
+
+  /** Number of nonzeros of the matrix */
+  Index nonzeros_;
+  ///@}
+
+  /** @name Information about most recent factorization/solve */
+  ///@{
+  /** Number of negative eigenvalues */
+  EigenvalueSignCount eigenvalue_sign_count_;
+  ///@}
+
+  /** @name Initialization flags */
+  ///@{
+  /** Flag indicating if internal data is initialized.
+   *
+   *  For initialization, this object needs to have seen a matrix
+   */
+  bool initialized_;
+  /** Flag indicating if the matrix has to be refactorized because
+   *  the pivot tolerance has been changed.
+   */
+  bool pivtol_changed_;
+  /** Flag that is true if we just requested the values of the
+   *  matrix again (SYMSOLVER_CALL_AGAIN) and have to factorize
+   *  again.
+   */
+  bool refactorize_;
+  ///@}
+
+  /** @name Solver specific data/options */
+  ///@{
+  /** IJ */
+  IjResult ij_ = {.code=LeopardReturnCode_Ok, .object=nullptr};
+  /** Ordering */
+  OrderingResult ordering_ = {.code=LeopardReturnCode_Ok, .object=nullptr};
+  /** OrderedIj */
+  OrderedIjResult ordered_ij_ = {.code=LeopardReturnCode_Ok, .object=nullptr};
+  /** AssemblyTree */
+  AssemblyTreeResult assembly_tree_ = {.code=LeopardReturnCode_Ok, .object=nullptr};
+  /** FactorizationSettings and LDLFactorization */
+#ifdef IPOPT_SINGLE
+  FactorizationSettingsF32* factorization_settings_ = nullptr;
+  LDLFactorizationResultF32 ldl_factorization_ = {.code=LeopardReturnCode_Ok, .object=nullptr};
+#else
+  FactorizationSettingsF64* factorization_settings_ = nullptr;
+  LDLFactorizationResultF64 ldl_factorization_ = {.code=LeopardReturnCode_Ok, .object=nullptr};
+#endif
+
+  /** Pivot tolerance */
+  Number pivtol_;
+  /** Maximal pivot tolerance */
+  Number pivtolmax_;
+  /** Array ptr containing IPopt natural Number type*/
+  Number* a_;
+  ///@}
+
+  /** @name Internal functions */
+  ///@{
+  /** TODO Call MA57AX and reserve memory for MA57 data.
+   *
+   *  TODO Reserve memory for iw_ and ikeep_, call MA57AD to perform
+   *  symbolic manipulations, and reserve all the remaining data memory
+   */
+  ESymSolverStatus SymbolicFactorization(
+      const Index *airn,
+      const Index *ajcn
+  );
+
+  /** TODO Call MA57BX to factorize the Matrix.
+   *
+   *  It is assumed that the first nonzeros_ element of a_ contain the values
+   *  of the matrix to be factorized.
+   */
+  ESymSolverStatus Factorization(
+      const Index *airn,
+      const Index *ajcn,
+      bool check_NegEVals,
+      Index numberOfNegEVals
+  );
+
+  /** Call TODO to do the backsolve. */
+  ESymSolverStatus Backsolve(
+      Index nrhs,
+      Number *rhs_vals
+  );
+  ///@}
+};
+
+} // namespace Ipopt
+#endif
diff --git a/src/Algorithm/LinearSolvers/IpLinearSolvers.c b/src/Algorithm/LinearSolvers/IpLinearSolvers.c
index 12858a430..87df18130 100644
--- a/src/Algorithm/LinearSolvers/IpLinearSolvers.c
+++ b/src/Algorithm/LinearSolvers/IpLinearSolvers.c
@@ -60,6 +60,9 @@ IpoptLinearSolver IpoptGetAvailableLinearSolvers(
    solvers |= IPOPTLINEARSOLVER_MUMPS;
 #endif
 
+  // TODO: Implement HAS_LEOPARD macro
+  solvers |= IPOPTLINEARSOLVER_LEOPARD;
+
 #if defined(IPOPT_HAS_LINEARSOLVERLOADER)
    if( !buildinonly )
    {
diff --git a/src/Algorithm/LinearSolvers/IpLinearSolvers.h b/src/Algorithm/LinearSolvers/IpLinearSolvers.h
index 3cb57bef4..c077f500a 100644
--- a/src/Algorithm/LinearSolvers/IpLinearSolvers.h
+++ b/src/Algorithm/LinearSolvers/IpLinearSolvers.h
@@ -21,6 +21,7 @@
 #define IPOPTLINEARSOLVER_SPRAL   0x100u
 #define IPOPTLINEARSOLVER_WSMP    0x200u
 #define IPOPTLINEARSOLVER_MUMPS   0x400u
+#define IPOPTLINEARSOLVER_LEOPARD  0x800u
 
 #ifdef __cplusplus
 extern "C"
diff --git a/src/Algorithm/LinearSolvers/IpLinearSolversRegOp.cpp b/src/Algorithm/LinearSolvers/IpLinearSolversRegOp.cpp
index 465cfe334..319bd16e1 100644
--- a/src/Algorithm/LinearSolvers/IpLinearSolversRegOp.cpp
+++ b/src/Algorithm/LinearSolvers/IpLinearSolversRegOp.cpp
@@ -17,6 +17,8 @@
 #include "IpMa97SolverInterface.hpp"
 #include "IpMa28TDependencyDetector.hpp"
 #include "IpPardisoSolverInterface.hpp"
+// TODO IMPLEMENT IPOPT_HAS_LEOPARD
+#include "IpLeopardSolverInterface.hpp"
 #ifdef IPOPT_HAS_PARDISO_MKL
 #include "IpPardisoMKLSolverInterface.hpp"
 #endif
@@ -116,6 +118,13 @@ void RegisterOptions_LinearSolvers(
    }
 #endif
 
+// TODO: Implement IPOPT_HAS_LEOPARD
+if( availablesolvers & IPOPTLINEARSOLVER_LEOPARD )
+{
+  roptions->SetRegisteringCategory("Leopard Linear Solver");
+  LeopardSolverInterface::RegisterOptions(roptions);
+}
+
 #if ((defined(COINHSL_HAS_MA28) && !defined(IPOPT_SINGLE)) || (defined(COINHSL_HAS_MA28S) && defined(IPOPT_SINGLE))) && defined(F77_FUNC)
    roptions->SetRegisteringCategory("MA28 Linear Solver");
    Ma28TDependencyDetector::RegisterOptions(roptions);
diff --git a/src/Makefile.am b/src/Makefile.am
index e7950dfc7..e6d67e470 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -218,6 +218,9 @@ if COIN_HAS_MUMPS
   libipopt_la_SOURCES += Algorithm/LinearSolvers/IpMumpsSolverInterface.cpp
 endif
 
+# TODO implement HAVE_LEOPARD
+libipopt_la_SOURCES += Algorithm/LinearSolvers/IpLeopardSolverInterface.cpp
+
 if COIN_HAS_SPRAL
   libipopt_la_SOURCES += Algorithm/LinearSolvers/IpSpralSolverInterface.cpp
 endif
diff --git a/src/Makefile.in b/src/Makefile.in
index c469a39f8..793357769 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -280,8 +280,9 @@ am_libipopt_la_OBJECTS = Common/IpDebug.lo Common/IpJournalist.lo \
 	Interfaces/IpTNLP.lo Interfaces/IpTNLPAdapter.lo \
 	Interfaces/IpTNLPReducer.lo $(am__objects_1) $(am__objects_2) \
 	$(am__objects_3) $(am__objects_4) $(am__objects_5) \
-	$(am__objects_6) $(am__objects_7) $(am__objects_8) \
-	$(am__objects_9) $(am__objects_10)
+	$(am__objects_6) $(am__objects_7) \
+	Algorithm/LinearSolvers/IpLeopardSolverInterface.lo \
+	$(am__objects_8) $(am__objects_9) $(am__objects_10)
 libipopt_la_OBJECTS = $(am_libipopt_la_OBJECTS)
 AM_V_lt = $(am__v_lt_@AM_V@)
 am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
@@ -362,6 +363,7 @@ am__depfiles_remade = Algorithm/$(DEPDIR)/IpAdaptiveMuUpdate.Plo \
 	Algorithm/Inexact/$(DEPDIR)/IpIterativePardisoSolverInterface.Plo \
 	Algorithm/Inexact/$(DEPDIR)/IpIterativeSolverTerminationTester.Plo \
 	Algorithm/LinearSolvers/$(DEPDIR)/IpIterativeWsmpSolverInterface.Plo \
+	Algorithm/LinearSolvers/$(DEPDIR)/IpLeopardSolverInterface.Plo \
 	Algorithm/LinearSolvers/$(DEPDIR)/IpLinearSolvers.Plo \
 	Algorithm/LinearSolvers/$(DEPDIR)/IpLinearSolversRegOp.Plo \
 	Algorithm/LinearSolvers/$(DEPDIR)/IpMa27TSolverInterface.Plo \
@@ -779,6 +781,8 @@ includeipopt_HEADERS = \
   Interfaces/IpTNLPReducer.hpp
 
 lib_LTLIBRARIES = libipopt.la
+
+# TODO implement HAVE_LEOPARD
 libipopt_la_SOURCES = Common/IpDebug.cpp Common/IpJournalist.cpp \
 	Common/IpObserver.cpp Common/IpOptionsList.cpp \
 	Common/IpRegOptions.cpp Common/IpTaggedObject.cpp \
@@ -857,8 +861,9 @@ libipopt_la_SOURCES = Common/IpDebug.cpp Common/IpJournalist.cpp \
 	Interfaces/IpTNLP.cpp Interfaces/IpTNLPAdapter.cpp \
 	Interfaces/IpTNLPReducer.cpp $(am__append_1) $(am__append_2) \
 	$(am__append_3) $(am__append_4) $(am__append_5) \
-	$(am__append_6) $(am__append_7) $(am__append_8) \
-	$(am__append_9) $(am__append_10)
+	$(am__append_6) $(am__append_7) \
+	Algorithm/LinearSolvers/IpLeopardSolverInterface.cpp \
+	$(am__append_8) $(am__append_9) $(am__append_10)
 AM_CPPFLAGS = \
   -I$(srcdir)/Common \
   -I$(srcdir)/LinAlg \
@@ -1246,6 +1251,9 @@ Algorithm/LinearSolvers/IpIterativeWsmpSolverInterface.lo:  \
 Algorithm/LinearSolvers/IpMumpsSolverInterface.lo:  \
 	Algorithm/LinearSolvers/$(am__dirstamp) \
 	Algorithm/LinearSolvers/$(DEPDIR)/$(am__dirstamp)
+Algorithm/LinearSolvers/IpLeopardSolverInterface.lo:  \
+	Algorithm/LinearSolvers/$(am__dirstamp) \
+	Algorithm/LinearSolvers/$(DEPDIR)/$(am__dirstamp)
 Algorithm/LinearSolvers/IpSpralSolverInterface.lo:  \
 	Algorithm/LinearSolvers/$(am__dirstamp) \
 	Algorithm/LinearSolvers/$(DEPDIR)/$(am__dirstamp)
@@ -1383,6 +1391,7 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@Algorithm/Inexact/$(DEPDIR)/IpIterativePardisoSolverInterface.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@Algorithm/Inexact/$(DEPDIR)/IpIterativeSolverTerminationTester.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@Algorithm/LinearSolvers/$(DEPDIR)/IpIterativeWsmpSolverInterface.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@Algorithm/LinearSolvers/$(DEPDIR)/IpLeopardSolverInterface.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@Algorithm/LinearSolvers/$(DEPDIR)/IpLinearSolvers.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@Algorithm/LinearSolvers/$(DEPDIR)/IpLinearSolversRegOp.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@Algorithm/LinearSolvers/$(DEPDIR)/IpMa27TSolverInterface.Plo@am__quote@ # am--include-marker
@@ -1798,6 +1807,7 @@ distclean: distclean-recursive
 	-rm -f Algorithm/Inexact/$(DEPDIR)/IpIterativePardisoSolverInterface.Plo
 	-rm -f Algorithm/Inexact/$(DEPDIR)/IpIterativeSolverTerminationTester.Plo
 	-rm -f Algorithm/LinearSolvers/$(DEPDIR)/IpIterativeWsmpSolverInterface.Plo
+	-rm -f Algorithm/LinearSolvers/$(DEPDIR)/IpLeopardSolverInterface.Plo
 	-rm -f Algorithm/LinearSolvers/$(DEPDIR)/IpLinearSolvers.Plo
 	-rm -f Algorithm/LinearSolvers/$(DEPDIR)/IpLinearSolversRegOp.Plo
 	-rm -f Algorithm/LinearSolvers/$(DEPDIR)/IpMa27TSolverInterface.Plo
@@ -1972,6 +1982,7 @@ maintainer-clean: maintainer-clean-recursive
 	-rm -f Algorithm/Inexact/$(DEPDIR)/IpIterativePardisoSolverInterface.Plo
 	-rm -f Algorithm/Inexact/$(DEPDIR)/IpIterativeSolverTerminationTester.Plo
 	-rm -f Algorithm/LinearSolvers/$(DEPDIR)/IpIterativeWsmpSolverInterface.Plo
+	-rm -f Algorithm/LinearSolvers/$(DEPDIR)/IpLeopardSolverInterface.Plo
 	-rm -f Algorithm/LinearSolvers/$(DEPDIR)/IpLinearSolvers.Plo
 	-rm -f Algorithm/LinearSolvers/$(DEPDIR)/IpLinearSolversRegOp.Plo
 	-rm -f Algorithm/LinearSolvers/$(DEPDIR)/IpMa27TSolverInterface.Plo