diff --git a/Grid/parallelIO/IldgIO.h b/Grid/parallelIO/IldgIO.h
index 3cfc1349..16951a26 100644
--- a/Grid/parallelIO/IldgIO.h
+++ b/Grid/parallelIO/IldgIO.h
@@ -250,8 +250,7 @@ class GridLimeReader : public BinaryIO {
   ////////////////////////////////////////////
   // Read a generic serialisable object
   ////////////////////////////////////////////
-  template<class serialisable_object>
-  void readLimeObject(serialisable_object &object,std::string object_name,std::string record_name)
+  void readLimeObject(std::string &xmlstring,std::string record_name)
   {
     // should this be a do while; can we miss a first record??
     while ( limeReaderNextRecord(LimeR) == LIME_SUCCESS ) { 
@@ -266,15 +265,23 @@ class GridLimeReader : public BinaryIO {
 	limeReaderReadData((void *)&xmlc[0], &nbytes, LimeR);    
 	//	std::cout << GridLogMessage<< " readLimeObject matches XML " << &xmlc[0] <<std::endl;
 
-  std::string xmlstring(&xmlc[0]);
-	XmlReader RD(xmlstring, true, "");
-	read(RD,object_name,object);
+   xmlstring = std::string(&xmlc[0]);
 	return;
       }
 
     }  
     assert(0);
   }
+
+  template<class serialisable_object>
+  void readLimeObject(serialisable_object &object,std::string object_name,std::string record_name)
+  {
+    std::string xmlstring;
+
+    readLimeObject(xmlstring, record_name);
+	  XmlReader RD(xmlstring, true, "");
+	  read(RD,object_name,object);
+  }
 };
 
 class GridLimeWriter : public BinaryIO 
diff --git a/Grid/serialisation/XmlIO.cc b/Grid/serialisation/XmlIO.cc
index e793c2f9..96f07f34 100644
--- a/Grid/serialisation/XmlIO.cc
+++ b/Grid/serialisation/XmlIO.cc
@@ -121,17 +121,26 @@ XmlReader::XmlReader(const std::string &s,  const bool isBuffer,
   }
 }
 
+#define XML_SAFE_NODE(expr)\
+if (expr)\
+{\
+  node_ = expr;\
+  return true;\
+}\
+else\
+{\
+  return false;\
+}
+
 bool XmlReader::push(const std::string &s)
 {
-  if (node_.child(s.c_str()))
+  if (s.empty())
   {
-    node_ = node_.child(s.c_str());
-
-    return true;
+    XML_SAFE_NODE(node_.first_child());
   }
   else
   {
-    return false;
+    XML_SAFE_NODE(node_.child(s.c_str()));
   }
 }
 
@@ -142,18 +151,26 @@ void XmlReader::pop(void)
 
 bool XmlReader::nextElement(const std::string &s)
 {
-  if (node_.next_sibling(s.c_str()))
+  if (s.empty())
   {
-    node_ = node_.next_sibling(s.c_str());
-    
-    return true;
+    XML_SAFE_NODE(node_.next_sibling());
   }
   else
   {
-    return false;
+    XML_SAFE_NODE(node_.next_sibling(s.c_str()));
   }
 }
 
+void XmlReader::readCurrentSubtree(std::string &s)
+{
+  std::ostringstream oss; 
+  pugi::xml_document doc;
+
+  doc.append_copy(node_);
+  doc.save(oss, indent_.c_str(), pugi::format_default | pugi::format_no_declaration);
+  s = oss.str();
+}
+
 template <>
 void XmlReader::readDefault(const std::string &s, std::string &output)
 {
diff --git a/Grid/serialisation/XmlIO.h b/Grid/serialisation/XmlIO.h
index 17ccb32e..a26a33c5 100644
--- a/Grid/serialisation/XmlIO.h
+++ b/Grid/serialisation/XmlIO.h
@@ -72,16 +72,18 @@ namespace Grid
     XmlReader(const std::string &fileName, const bool isBuffer = false, 
               std::string toplev = std::string("grid") );
     virtual ~XmlReader(void) = default;
-    bool push(const std::string &s);
+    bool push(const std::string &s = "");
     void pop(void);
-    bool nextElement(const std::string &s);
+    bool nextElement(const std::string &s = "");
     template <typename U>
     void readDefault(const std::string &s, U &output);
     template <typename U>
     void readDefault(const std::string &s, std::vector<U> &output);
+    void readCurrentSubtree(std::string &s);
   private:
     void checkParse(const pugi::xml_parse_result &result, const std::string name);
   private:
+    const std::string  indent_{"  "};
     pugi::xml_document doc_;
     pugi::xml_node     node_;
     std::string        fileName_;
diff --git a/Hadrons/EigenPack.hpp b/Hadrons/EigenPack.hpp
index 49fecc34..0be998b7 100644
--- a/Hadrons/EigenPack.hpp
+++ b/Hadrons/EigenPack.hpp
@@ -39,22 +39,31 @@ BEGIN_HADRONS_NAMESPACE
 #define HADRONS_DEFAULT_LANCZOS_NBASIS 60
 #endif
 
+#define HADRONS_DUMP_EP_METADATA \
+LOG(Message) << "Eigenpack metadata:" << std::endl;\
+LOG(Message) << "* operator" << std::endl;\
+LOG(Message) << record.operatorXml << std::endl;\
+LOG(Message) << "* solver" << std::endl;\
+LOG(Message) << record.solverXml << std::endl;
+
+struct PackRecord
+{
+    std::string operatorXml, solverXml;
+};
+
+struct VecRecord: Serializable
+{
+    GRID_SERIALIZABLE_CLASS_MEMBERS(VecRecord,
+                                    unsigned int, index,
+                                    double,       eval);
+    VecRecord(void): index(0), eval(0.) {}
+};
+
 template <typename F>
 class EigenPack
 {
 public:
     typedef F Field;
-    struct PackRecord
-    {
-        std::string operatorXml, solverXml;
-    };
-    struct VecRecord: Serializable
-    {
-        GRID_SERIALIZABLE_CLASS_MEMBERS(VecRecord,
-                                        unsigned int, index,
-                                        double,       eval);
-        VecRecord(void): index(0), eval(0.) {}
-    };
 public:
     std::vector<RealD> eval;
     std::vector<F>     evec;
@@ -81,11 +90,16 @@ public:
             for(int k = 0; k < evec.size(); ++k)
             {
                 basicReadSingle(evec[k], eval[k], evecFilename(fileStem, k, traj), k);
+                if (k == 0)
+                {
+                    HADRONS_DUMP_EP_METADATA;
+                }
             }
         }
         else
         {
             basicRead(evec, eval, evecFilename(fileStem, -1, traj), evec.size());
+            HADRONS_DUMP_EP_METADATA;
         }
     }
 
@@ -103,6 +117,39 @@ public:
             basicWrite(evecFilename(fileStem, -1, traj), evec, eval, evec.size());
         }
     }
+
+    static void readHeader(PackRecord &record, ScidacReader &binReader)
+    {
+        std::string recordXml;
+
+        binReader.readLimeObject(recordXml, SCIDAC_FILE_XML);
+        XmlReader xmlReader(recordXml, true, "eigenPackPar");
+        xmlReader.push();
+        xmlReader.readCurrentSubtree(record.operatorXml);
+        xmlReader.nextElement();
+        xmlReader.readCurrentSubtree(record.solverXml);
+    }
+
+    template <typename T>
+    static void readElement(T &evec, VecRecord &vecRecord, ScidacReader &binReader)
+    {
+        binReader.readScidacFieldRecord(evec, vecRecord);
+    }
+
+    static void writeHeader(ScidacWriter &binWriter, PackRecord &record)
+    {
+        XmlWriter xmlWriter("", "eigenPackPar");
+
+        xmlWriter.pushXmlString(record.operatorXml);
+        xmlWriter.pushXmlString(record.solverXml);
+        binWriter.writeLimeObject(1, 1, xmlWriter, "parameters", SCIDAC_FILE_XML);
+    }
+
+    template <typename T>
+    static void writeElement(ScidacWriter &binWriter, T &evec, VecRecord &vecRecord)
+    {
+        binWriter.writeScidacFieldRecord(evec, vecRecord, DEFAULT_ASCII_PREC);
+    }
 protected:
     std::string evecFilename(const std::string stem, const int vec, const int traj)
     {
@@ -122,16 +169,16 @@ protected:
     void basicRead(std::vector<T> &evec, std::vector<RealD> &eval,
                    const std::string filename, const unsigned int size)
     {
-        ScidacReader    binReader;
+        ScidacReader binReader;
 
         binReader.open(filename);
-        binReader.skipPastObjectRecord(SCIDAC_FILE_XML);
+        readHeader(record, binReader);
         for(int k = 0; k < size; ++k) 
         {
             VecRecord vecRecord;
 
             LOG(Message) << "Reading eigenvector " << k << std::endl;
-            binReader.readScidacFieldRecord(evec[k], vecRecord);
+            readElement(evec[k], vecRecord, binReader);
             if (vecRecord.index != k)
             {
                 HADRONS_ERROR(Io, "Eigenvector " + std::to_string(k) + " has a"
@@ -151,9 +198,9 @@ protected:
         VecRecord    vecRecord;
 
         binReader.open(filename);
-        binReader.skipPastObjectRecord(SCIDAC_FILE_XML);
+        readHeader(record, binReader);
         LOG(Message) << "Reading eigenvector " << index << std::endl;
-        binReader.readScidacFieldRecord(evec, vecRecord);
+        readElement(evec, vecRecord, binReader);
         if (vecRecord.index != index)
         {
             HADRONS_ERROR(Io, "Eigenvector " + std::to_string(index) + " has a"
@@ -169,13 +216,10 @@ protected:
                     const std::vector<RealD> &eval, const unsigned int size)
     {
         ScidacWriter binWriter(evec[0]._grid->IsBoss());
-        XmlWriter    xmlWriter("", "eigenPackPar");
 
         makeFileDir(filename, evec[0]._grid);
-        xmlWriter.pushXmlString(record.operatorXml);
-        xmlWriter.pushXmlString(record.solverXml);
         binWriter.open(filename);
-        binWriter.writeLimeObject(1, 1, xmlWriter, "parameters", SCIDAC_FILE_XML);
+        writeHeader(binWriter, record);
         for(int k = 0; k < size; ++k) 
         {
             VecRecord vecRecord;
@@ -183,7 +227,7 @@ protected:
             vecRecord.index = k;
             vecRecord.eval  = eval[k];
             LOG(Message) << "Writing eigenvector " << k << std::endl;
-            binWriter.writeScidacFieldRecord(evec[k], vecRecord, DEFAULT_ASCII_PREC);
+            writeElement(binWriter, evec[k], vecRecord);
         }
         binWriter.close();
     }
@@ -193,18 +237,15 @@ protected:
                           const RealD eval, const unsigned int index)
     {
         ScidacWriter binWriter(evec._grid->IsBoss());
-        XmlWriter    xmlWriter("", "eigenPackPar");
         VecRecord    vecRecord;
 
         makeFileDir(filename, evec._grid);
-        xmlWriter.pushXmlString(record.operatorXml);
-        xmlWriter.pushXmlString(record.solverXml);
         binWriter.open(filename);
-        binWriter.writeLimeObject(1, 1, xmlWriter, "parameters", SCIDAC_FILE_XML);
+        writeHeader(binWriter, record);
         vecRecord.index = index;
         vecRecord.eval  = eval;
         LOG(Message) << "Writing eigenvector " << index << std::endl;
-        binWriter.writeScidacFieldRecord(evec, vecRecord, DEFAULT_ASCII_PREC);
+        writeElement(binWriter, evec, vecRecord);
         binWriter.close();
     }
 };
@@ -318,6 +359,8 @@ using CoarseFermionEigenPack = CoarseEigenPack<
                                    typename FImpl::SiteComplex, 
                                    nBasis>::CoarseField>;
 
+#undef HADRONS_DUMP_EP_METADATA
+
 END_HADRONS_NAMESPACE
 
 #endif // Hadrons_EigenPack_hpp_
diff --git a/Hadrons/Makefile.am b/Hadrons/Makefile.am
index fe851aee..4ec45c03 100644
--- a/Hadrons/Makefile.am
+++ b/Hadrons/Makefile.am
@@ -1,5 +1,6 @@
+SUBDIRS = . Utilities
+
 lib_LIBRARIES = libHadrons.a
-bin_PROGRAMS  = HadronsXmlRun
 
 include modules.inc
 
@@ -31,6 +32,3 @@ nobase_libHadrons_a_HEADERS = \
 	ModuleFactory.hpp         \
 	Solver.hpp                \
 	VirtualMachine.hpp
-
-HadronsXmlRun_SOURCES = HadronsXmlRun.cc
-HadronsXmlRun_LDADD   = libHadrons.a -lGrid
diff --git a/Hadrons/Utilities/EigenPackCast.cc b/Hadrons/Utilities/EigenPackCast.cc
new file mode 100644
index 00000000..cf35a550
--- /dev/null
+++ b/Hadrons/Utilities/EigenPackCast.cc
@@ -0,0 +1,179 @@
+#include <Hadrons/EigenPack.hpp>
+#include <Hadrons/Environment.hpp>
+
+using namespace Grid;
+using namespace QCD;
+using namespace Hadrons;
+
+template <typename FOut, typename FIn>
+void convert(const std::string outFilename, const std::string inFilename, 
+             const unsigned int Ls, const bool rb, const unsigned int size, 
+             const bool multiFile)
+{
+    assert(outFilename != inFilename);
+    
+    typedef EigenPack<FOut>            EPOut;
+    typedef EigenPack<FIn>             EPIn;
+    typedef typename FOut::vector_type VTypeOut;
+    typedef typename FIn::vector_type  VTypeIn;
+
+    std::shared_ptr<GridCartesian>         gInBase, gOutBase, gIn5, gOut5;
+    std::shared_ptr<GridRedBlackCartesian> rbgIn, rbgOut;
+    GridBase                               *gIn, *gOut;
+
+    auto         dim     = GridDefaultLatt();
+    unsigned int nd      = dim.size();
+    auto         simdOut = GridDefaultSimd(nd, VTypeOut::Nsimd());
+    auto         simdIn  = GridDefaultSimd(nd, VTypeIn::Nsimd());
+
+    gOutBase.reset(SpaceTimeGrid::makeFourDimGrid(dim, simdOut, GridDefaultMpi()));
+    gInBase.reset(SpaceTimeGrid::makeFourDimGrid(dim, simdIn, GridDefaultMpi()));
+    if (rb)
+    {
+        if (Ls > 1)
+        {
+            rbgOut.reset(SpaceTimeGrid::makeFiveDimRedBlackGrid(Ls, gOutBase.get()));
+            rbgIn.reset(SpaceTimeGrid::makeFiveDimRedBlackGrid(Ls, gInBase.get()));
+        }
+        else
+        {
+            rbgOut.reset(SpaceTimeGrid::makeFourDimRedBlackGrid(gOutBase.get()));
+            rbgIn.reset(SpaceTimeGrid::makeFourDimRedBlackGrid(gInBase.get()));
+        }
+        gOut = rbgOut.get();
+        gIn  = rbgIn.get();
+    }
+    else
+    {
+        if (Ls > 1)
+        {
+            gOut5.reset(SpaceTimeGrid::makeFiveDimGrid(Ls, gOutBase.get()));
+            gIn5.reset(SpaceTimeGrid::makeFiveDimGrid(Ls, gInBase.get()));
+            gOut = gOut5.get();
+            gIn  = gIn5.get();
+        }
+        else
+        {
+            gOut = gOutBase.get();
+            gIn  = gInBase.get();
+        }
+    }
+
+    FOut bufOut(gOut);
+    FIn  bufIn(gIn), testIn(gIn);
+
+    LOG(Message) << "==== EIGENPACK CONVERSION" << std::endl;
+    LOG(Message) << "Lattice       : " << gIn->GlobalDimensions() << std::endl;
+    LOG(Message) << "Checkerboarded: " << (rb ? "yes" : "no") << std::endl;
+    LOG(Message) << "In path       : " << inFilename  << std::endl;
+    LOG(Message) << "In type       : " << typeName<FIn>() << std::endl;
+    LOG(Message) << "Out path      : " << outFilename << std::endl;
+    LOG(Message) << "Out type      : " << typeName<FOut>() << std::endl;
+    LOG(Message) << "#vectors      : " << size << std::endl;
+    LOG(Message) << "Multifile     : " << (multiFile ? "yes" : "no") << std::endl;
+    if (multiFile)
+    {
+        for(unsigned int k = 0; k < size; ++k)
+        {
+            ScidacWriter binWriter(gOut->IsBoss());
+            ScidacReader binReader;
+            PackRecord   record;
+            VecRecord    vecRecord;
+            std::string  outV = outFilename + "/v" + std::to_string(k) + ".bin";
+            std::string  inV  = inFilename + "/v" + std::to_string(k) + ".bin";
+
+            LOG(Message) << "==== Converting vector " << k << std::endl;
+            LOG(Message) << "In : " << inV  << std::endl;
+            LOG(Message) << "Out: " << outV << std::endl;
+            makeFileDir(outV, gOut);
+            binWriter.open(outV);
+            binReader.open(inV);
+            EPIn::readHeader(record, binReader);
+            EPOut::writeHeader(binWriter, record);
+            EPIn::readElement(bufIn, vecRecord, binReader);
+            precisionChange(bufOut, bufIn);
+            precisionChange(testIn, bufOut);
+            testIn -= bufIn;
+            LOG(Message) << "Diff norm^2: " << norm2(testIn) << std::endl;
+            EPOut::writeElement(binWriter, bufOut, vecRecord);
+            binWriter.close();
+            binReader.close();
+        }
+    }
+    else
+    {
+        ScidacWriter binWriter(gOut->IsBoss());
+        ScidacReader binReader;
+        PackRecord   record;
+
+        makeFileDir(outFilename, gOut);
+        binWriter.open(outFilename);
+        binReader.open(inFilename);
+        EPIn::readHeader(record, binReader);
+        EPOut::writeHeader(binWriter, record);
+        for(unsigned int k = 0; k < size; ++k)
+        {
+            VecRecord vecRecord;
+
+            LOG(Message) << "==== Converting vector " << k << std::endl;
+            EPIn::readElement(bufIn, vecRecord, binReader);
+            precisionChange(bufOut, bufIn);
+            precisionChange(testIn, bufOut);
+            testIn -= bufIn;
+            LOG(Message) << "Diff norm^2: " << norm2(testIn) << std::endl;
+            EPOut::writeElement(binWriter, bufOut, vecRecord);
+        }
+        binWriter.close();
+        binReader.close();
+    }
+}
+
+#ifndef FOUT
+#warning "FOUT undefined (set to WilsonImplF::FermionField by default)"
+#define FOUT WilsonImplF::FermionField
+#endif
+#ifndef FIN
+#warning "FIN undefined (set to WilsonImplD::FermionField by default)"
+#define FIN WilsonImplD::FermionField
+#endif
+
+int main(int argc, char *argv[])
+{
+    // parse command line
+    std::string  outFilename, inFilename;
+    unsigned int size, Ls;
+    bool         rb, multiFile;
+    
+    if (argc < 7)
+    {
+        std::cerr << "usage: " << argv[0] << " <out eigenpack> <in eigenpack> <Ls> <red-black (0|1)> <#vector> <multifile (0|1)> [Grid options]";
+        std::cerr << std::endl;
+        std::exit(EXIT_FAILURE);
+    }
+    outFilename = argv[1];
+    inFilename  = argv[2];
+    Ls          = std::stoi(std::string(argv[3]));
+    rb          = (std::string(argv[4]) != "0");
+    size        = std::stoi(std::string(argv[5]));
+    multiFile   = (std::string(argv[6]) != "0");
+    
+    // initialization
+    Grid_init(&argc, &argv);
+    initLogger();
+
+    // execution
+    try
+    {
+        convert<FOUT, FIN>(outFilename, inFilename, Ls, rb, size, multiFile);
+    }
+    catch (const std::exception& e)
+    {
+        Exceptions::abort(e);
+    }
+
+    // epilogue
+    LOG(Message) << "Grid is finalizing now" << std::endl;
+    Grid_finalize();
+    
+    return EXIT_SUCCESS;
+}
diff --git a/Hadrons/HadronsXmlRun.cc b/Hadrons/Utilities/HadronsXmlRun.cc
similarity index 100%
rename from Hadrons/HadronsXmlRun.cc
rename to Hadrons/Utilities/HadronsXmlRun.cc
diff --git a/Hadrons/Utilities/Makefile.am b/Hadrons/Utilities/Makefile.am
new file mode 100644
index 00000000..62c29ef9
--- /dev/null
+++ b/Hadrons/Utilities/Makefile.am
@@ -0,0 +1,10 @@
+AM_LDFLAGS += -L../../Hadrons
+
+bin_PROGRAMS = HadronsXmlRun FermionEigenPackCastToSingle
+
+HadronsXmlRun_SOURCES = HadronsXmlRun.cc
+HadronsXmlRun_LDADD   = -lHadrons -lGrid
+
+FermionEigenPackCastToSingle_SOURCES  = EigenPackCast.cc
+FermionEigenPackCastToSingle_CXXFLAGS = $(AM_CXXFLAGS) -DFIN=WilsonImplD::FermionField -DFOUT=WilsonImplF::FermionField
+FermionEigenPackCastToSingle_LDADD    = -lHadrons -lGrid
diff --git a/configure.ac b/configure.ac
index f57b00ad..d362ed5a 100644
--- a/configure.ac
+++ b/configure.ac
@@ -562,6 +562,7 @@ AC_CONFIG_FILES(tests/qdpxx/Makefile)
 AC_CONFIG_FILES(tests/testu01/Makefile)
 AC_CONFIG_FILES(benchmarks/Makefile)
 AC_CONFIG_FILES(Hadrons/Makefile)
+AC_CONFIG_FILES(Hadrons/Utilities/Makefile)
 AC_OUTPUT
 
 echo ""