diff --git a/EventVisualisation/Workflow/CMakeLists.txt b/EventVisualisation/Workflow/CMakeLists.txt
index 635b1ad82e047..36f12dc61652f 100644
--- a/EventVisualisation/Workflow/CMakeLists.txt
+++ b/EventVisualisation/Workflow/CMakeLists.txt
@@ -21,18 +21,28 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2"
           COMPONENT_NAME eve
           TARGETVARNAME targetName
           SOURCES
-                                src/O2DPLDisplay.cxx
-                                src/FileProducer.cxx
+                src/O2DPLDisplay.cxx
+                src/FileProducer.cxx
+                src/EveWorkflowHelper.cxx
+                src/EveConfiguration.cxx
           PUBLIC_LINK_LIBRARIES
-                                O2::EventVisualisationBase
-                                O2::EventVisualisationDetectors
-                                O2::GPUO2Interface
-                                O2::GPUWorkflowHelper
-                                O2::DataFormatsGlobalTracking
-                                O2::TPCFastTransformation
-                                O2::TRDBase
-                                O2::TOFBase
-                                O2::TPCReconstruction
-                                O2::GlobalTrackingWorkflowHelpers)
+                O2::DataFormatsGlobalTracking
+                O2::DetectorsRaw
+                O2::DetectorsVertexing
+                O2::EventVisualisationBase
+                O2::EventVisualisationDetectors
+                O2::FrameworkFoundation
+                O2::FT0Workflow
+                O2::GlobalTrackingWorkflowHelpers
+                O2::GlobalTrackingWorkflowReaders
+                O2::ITSMFTWorkflow
+                O2::MFTWorkflow
+                O2::TOFBase
+                O2::TOFWorkflowIO
+                O2::TPCReconstruction
+                O2::TPCWorkflow
+                O2::TRDBase
+                O2::TRDWorkflowIO
+          )
   target_include_directories(${targetName} PUBLIC "include")
 endif()
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/EveConfiguration.h b/EventVisualisation/Workflow/include/EveWorkflow/EveConfiguration.h
new file mode 100644
index 0000000000000..d7657e4f13f6a
--- /dev/null
+++ b/EventVisualisation/Workflow/include/EveWorkflow/EveConfiguration.h
@@ -0,0 +1,78 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file
+/// \author Julian Myrcha
+
+#ifndef ALICE_O2_EVENTVISUALISATION_WORKFLOW_EVECONFIGURATION_H
+#define ALICE_O2_EVENTVISUALISATION_WORKFLOW_EVECONFIGURATION_H
+
+#include "DataFormatsTPC/Constants.h"
+#include "TRDBase/GeometryFlat.h"
+#include "DataFormatsITSMFT/TopologyDictionary.h"
+
+#include <memory>
+#include <array>
+#include <vector>
+#include <functional>
+#include <gsl/gsl>
+
+class TH1F;
+
+namespace o2
+{
+namespace event_visualisation
+{
+template <class T>
+struct DefaultPtr {
+  typedef T type;
+};
+template <class T>
+struct ConstPtr {
+  typedef const T type;
+};
+
+template <template <typename T> class S>
+struct CalibObjectsTemplate {
+  typename S<o2::trd::GeometryFlat>::type* trdGeometry = nullptr;
+  typename S<o2::itsmft::TopologyDictionary>::type* itsPatternDict = nullptr;
+};
+
+typedef CalibObjectsTemplate<DefaultPtr> CalibObjects; // NOTE: These 2 must have identical layout since they are memcopied
+typedef CalibObjectsTemplate<ConstPtr> CalibObjectsConst;
+
+struct SettingsGRP {
+  // All new members must be sizeof(int) resp. sizeof(float) for alignment reasons!
+  float solenoidBz = -5.00668;  // solenoid field strength
+  int constBz = 0;              // for test-MC events with constant Bz
+  int homemadeEvents = 0;       // Toy-MC events
+  int continuousMaxTimeBin = 0; // 0 for triggered events, -1 for default of 23ms
+  int needsClusterer = 0;       // Set to true if the data requires the clusterizer
+};
+
+struct SettingsProcessing {
+  bool runMC;
+};
+
+struct EveConfiguration {
+  EveConfiguration() = default;
+  ~EveConfiguration() = default;
+  EveConfiguration(const EveConfiguration&) = default;
+  SettingsGRP configGRP;
+  CalibObjectsConst configCalib;
+  SettingsProcessing configProcessing;
+  void ReadConfigurableParam();
+};
+
+} // namespace event_visualisation
+} // namespace o2
+
+#endif
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h b/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
new file mode 100644
index 0000000000000..6d41b5459f098
--- /dev/null
+++ b/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
@@ -0,0 +1,40 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file   EveWorkflowHelper.h
+/// \author julian.myrcha@cern.ch
+
+#ifndef ALICE_O2_EVENTVISUALISATION_WORKFLOW_EVEWORKFLOWHELPER_H
+#define ALICE_O2_EVENTVISUALISATION_WORKFLOW_EVEWORKFLOWHELPER_H
+
+#include "ReconstructionDataFormats/GlobalTrackID.h"
+#include "DataFormatsGlobalTracking/RecoContainer.h"
+#include "EveWorkflow/EveConfiguration.h"
+
+namespace o2::event_visualisation
+{
+class EveWorkflowHelper
+{
+  using GID = o2::dataformats::GlobalTrackID;
+
+ public:
+  struct tmpDataContainer {
+    std::vector<o2::BaseCluster<float>> ITSClustersArray;
+    std::vector<int> tpcLinkITS, tpcLinkTRD, tpcLinkTOF;
+    std::vector<const o2::track::TrackParCov*> globalTracks;
+    std::vector<float> globalTrackTimes;
+  };
+  static std::shared_ptr<const tmpDataContainer> compute(const o2::globaltracking::RecoContainer& recoCont, const CalibObjectsConst* calib = nullptr, GID::mask_t maskCl = GID::MASK_ALL, GID::mask_t maskTrk = GID::MASK_ALL, GID::mask_t maskMatch = GID::MASK_ALL);
+};
+} // namespace o2::event_visualisation
+
+#endif //ALICE_O2_EVENTVISUALISATION_WORKFLOW_EVEWORKFLOWHELPER_H
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/FileProducer.h b/EventVisualisation/Workflow/include/EveWorkflow/FileProducer.h
index 50cf537d1f1cf..71b2ee4d51a42 100644
--- a/EventVisualisation/Workflow/include/EveWorkflow/FileProducer.h
+++ b/EventVisualisation/Workflow/include/EveWorkflow/FileProducer.h
@@ -13,23 +13,33 @@
 /// \file    FileProducer.h
 /// \author julian.myrcha@cern.ch
 
-#ifndef FILEPRODUCER_FILEPRODUCER_H
-#define FILEPRODUCER_FILEPRODUCER_H
+#ifndef ALICE_O2_EVENTVISUALISATION_WORKFLOW_FILEPRODUCER_H
+#define ALICE_O2_EVENTVISUALISATION_WORKFLOW_FILEPRODUCER_H
 
 #include <string>
 #include <deque>
 
+namespace o2
+{
+namespace event_visualisation
+{
 class FileProducer
 {
  private:
   static std::deque<std::string> load(const std::string& path);
+
   size_t mFilesInFolder;
   std::string mPath;
   std::string mName;
 
  public:
-  explicit FileProducer(const std::string& path, const std::string& name = "tracks{}.json", int filesInFolder = 10);
+  explicit FileProducer(const std::string& path, int filesInFolder = 10,
+                        const std::string& name = "tracks{}.json");
+
   [[nodiscard]] std::string newFileName() const;
 };
 
-#endif //FILEPRODUCER_FILEPRODUCER_H
+} // namespace event_visualisation
+} // namespace o2
+
+#endif //ALICE_O2_EVENTVISUALISATION_WORKFLOW_FILEPRODUCER_H
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h b/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h
index fadc7db6b4d8b..1368be8ae9af0 100644
--- a/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h
+++ b/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h
@@ -9,10 +9,15 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#ifndef O2_GPU_DPL_DISPLAY_H
-#define O2_GPU_DPL_DISPLAY_H
+///
+/// \file   EveWorkflowHelper.h
+/// \author julian.myrcha@cern.ch
+
+#ifndef ALICE_O2_EVENTVISUALISATION_WORKFLOW_O2DPLDISPLAY_H
+#define ALICE_O2_EVENTVISUALISATION_WORKFLOW_O2DPLDISPLAY_H
 
 #include "ReconstructionDataFormats/GlobalTrackID.h"
+#include "EveWorkflow/EveConfiguration.h"
 #include "Framework/Task.h"
 #include <memory>
 
@@ -20,42 +25,54 @@ namespace o2::trd
 {
 class GeometryFlat;
 }
+
 namespace o2::globaltracking
 {
 struct DataRequest;
 }
+
 namespace o2::itsmft
 {
 class TopologyDictionary;
 }
 
-namespace o2::gpu
+namespace o2::event_visualisation
 {
-class GPUO2InterfaceDisplay;
-struct GPUO2InterfaceConfiguration;
 class TPCFastTransform;
 
-class O2GPUDPLDisplaySpec : public o2::framework::Task
+class O2DPLDisplaySpec : public o2::framework::Task
 {
  public:
-  O2GPUDPLDisplaySpec(bool useMC, o2::dataformats::GlobalTrackID::mask_t trkMask, o2::dataformats::GlobalTrackID::mask_t clMask, std::shared_ptr<o2::globaltracking::DataRequest> dataRequest) : mUseMC(useMC), mTrkMask(trkMask), mClMask(clMask), mDataRequest(dataRequest) {}
-  ~O2GPUDPLDisplaySpec() override = default;
+  O2DPLDisplaySpec(bool useMC, o2::dataformats::GlobalTrackID::mask_t trkMask,
+                   o2::dataformats::GlobalTrackID::mask_t clMask,
+                   std::shared_ptr<o2::globaltracking::DataRequest> dataRequest, std::string jsonPath,
+                   std::chrono::milliseconds timeInterval, int numberOfFiles, int numberOfTracks, bool eveHostNameMatch)
+    : mUseMC(useMC), mTrkMask(trkMask), mClMask(clMask), mDataRequest(dataRequest), mJsonPath(jsonPath), mTimeInteval(timeInterval), mNumberOfFiles(numberOfFiles), mNumberOfTracks(numberOfTracks), mEveHostNameMatch(eveHostNameMatch)
+  {
+    this->mTimeStamp = std::chrono::high_resolution_clock::now() - timeInterval; // first run meets condition
+  }
+  ~O2DPLDisplaySpec() override = default;
   void init(o2::framework::InitContext& ic) final;
   void run(o2::framework::ProcessingContext& pc) final;
   void endOfStream(o2::framework::EndOfStreamContext& ec) final;
 
  private:
   bool mUseMC = false;
+  bool mEveHostNameMatch;                 // empty or correct hostname
+  std::string mJsonPath;                  // folder where files are stored
+  std::chrono::milliseconds mTimeInteval; // minimal interval between files in miliseconds
+  int mNumberOfFiles;                     // maximun number of files in folder - newer replaces older
+  int mNumberOfTracks;                    // maximun number of track in single file (0 means no limit)
+  std::chrono::time_point<std::chrono::high_resolution_clock> mTimeStamp;
+
   o2::dataformats::GlobalTrackID::mask_t mTrkMask;
   o2::dataformats::GlobalTrackID::mask_t mClMask;
-  //std::unique_ptr<GPUO2InterfaceDisplay> mDisplay;
-  std::unique_ptr<GPUO2InterfaceConfiguration> mConfig;
-  std::unique_ptr<TPCFastTransform> mFastTransform;
+  std::unique_ptr<EveConfiguration> mConfig;
   std::unique_ptr<o2::trd::GeometryFlat> mTrdGeo;
   std::unique_ptr<o2::itsmft::TopologyDictionary> mITSDict;
   std::shared_ptr<o2::globaltracking::DataRequest> mDataRequest;
 };
 
-} // namespace o2::gpu
+} // namespace o2::event_visualisation
 
 #endif
diff --git a/EventVisualisation/Workflow/src/EveConfiguration.cxx b/EventVisualisation/Workflow/src/EveConfiguration.cxx
new file mode 100644
index 0000000000000..259009503cc75
--- /dev/null
+++ b/EventVisualisation/Workflow/src/EveConfiguration.cxx
@@ -0,0 +1,21 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file EveConfiguration.cxx
+/// \author julian.myrcha@cern.ch
+
+#include "EveWorkflow/EveConfiguration.h"
+
+using namespace o2::event_visualisation;
+
+void EveConfiguration::ReadConfigurableParam()
+{
+}
diff --git a/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx b/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
new file mode 100644
index 0000000000000..1e82f3dbaea84
--- /dev/null
+++ b/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
@@ -0,0 +1,163 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file EveWorkflowHelper.cxx
+/// \author julian.myrcha@cern.ch
+
+#include <EveWorkflow/EveWorkflowHelper.h>
+#include "DataFormatsTRD/TrackTRD.h"
+#include "ITStracking/IOUtils.h"
+#include "DataFormatsGlobalTracking/RecoContainerCreateTracksVariadic.h"
+#include <type_traits>
+
+using namespace o2::event_visualisation;
+
+std::shared_ptr<const o2::event_visualisation::EveWorkflowHelper::tmpDataContainer>
+  o2::event_visualisation::EveWorkflowHelper::compute(const o2::globaltracking::RecoContainer& recoCont,
+                                                      const CalibObjectsConst* calib, GID::mask_t maskCl,
+                                                      GID::mask_t maskTrk, GID::mask_t maskMatch)
+{
+  unsigned int nTracksTPCITSO2 = 0;
+  unsigned int nTOFMatches = 0;
+  unsigned int nTRDTracksITSTPCTRD = 0;
+  unsigned int nTRDTracksTPCTRD = 0;
+  unsigned int nTPCTOFMatches = 0;
+
+  auto retVal = std::make_shared<tmpDataContainer>();
+
+  if (maskCl[GID::ITS]) {
+    const auto& ITSClusterROFRec = recoCont.getITSClustersROFRecords();
+    const auto& clusITS = recoCont.getITSClusters();
+    if (clusITS.size() && ITSClusterROFRec.size()) {
+      if (calib && calib->itsPatternDict) {
+        const auto& patterns = recoCont.getITSClustersPatterns();
+        auto pattIt = patterns.begin();
+        retVal->ITSClustersArray.reserve(clusITS.size());
+        o2::its::ioutils::convertCompactClusters(clusITS, pattIt, retVal->ITSClustersArray, *calib->itsPatternDict);
+      }
+    }
+  }
+
+  if (maskTrk[GID::ITSTPC] && nTracksTPCITSO2 == 0) {
+    const auto& trkITSTPC = recoCont.getTPCITSTracks();
+    if (trkITSTPC.size()) {
+      nTracksTPCITSO2 = trkITSTPC.size();
+    }
+    LOG(info) << "Got " << nTracksTPCITSO2 << " ITS-TPC Tracks";
+  }
+
+  if ((maskMatch[GID::TOF] || maskMatch[GID::ITSTPCTOF] || maskMatch[GID::ITSTPCTRDTOF])) {
+    const auto& tofMatches = recoCont.getTOFMatches();
+    if (tofMatches.size()) {
+      nTOFMatches = tofMatches.size();
+    }
+  }
+
+  if (maskMatch[GID::TPCTOF] && nTPCTOFMatches == 0) {
+    const auto& tpctofMatches = recoCont.getTPCTOFMatches();
+    if (tpctofMatches.size()) {
+      nTPCTOFMatches = tpctofMatches.size();
+    }
+    LOG(info) << "Got " << nTPCTOFMatches << " TPC-TOF Matches";
+  }
+
+  if (maskTrk[GID::ITSTPCTRD]) {
+    const auto& trdTracks = recoCont.getITSTPCTRDTracks<o2::trd::TrackTRD>();
+    if (trdTracks.size()) {
+      nTRDTracksITSTPCTRD = trdTracks.size();
+    }
+    LOG(info) << "Got " << nTRDTracksITSTPCTRD << " ITS-TPC-TRD Tracks";
+  }
+
+  if (maskTrk[GID::TPCTRD] && nTRDTracksTPCTRD == 0) {
+    const auto& trdTracks = recoCont.getTPCTRDTracks<o2::trd::TrackTRD>();
+    if (trdTracks.size()) {
+      nTRDTracksTPCTRD = trdTracks.size();
+    }
+    LOG(info) << "Got " << nTRDTracksTPCTRD << " TPC-TRD Tracks";
+  }
+
+  if (maskTrk[GID::TPC]) {
+    const auto& tpcTracks = recoCont.getTPCTracks();
+    const auto& tpcClusRefs = recoCont.getTPCTracksClusterRefs();
+    if (nTracksTPCITSO2) {
+      retVal->tpcLinkITS.resize(tpcTracks.size(), -1);
+    }
+    if (nTOFMatches || nTPCTOFMatches) {
+      retVal->tpcLinkTOF.resize(tpcTracks.size(), -1);
+    }
+    if (nTRDTracksITSTPCTRD || nTRDTracksTPCTRD) {
+      retVal->tpcLinkTRD.resize(tpcTracks.size(), -1);
+    }
+    LOG(info) << "Got " << tpcTracks.size() << " TPC Tracks";
+  }
+
+  auto creator = [maskTrk, &recoCont, &retVal, nTracksTPCITSO2, nTPCTOFMatches](auto& trk, GID gid, float time, float) {
+    if (gid.getSource() == GID::ITSTPCTOF) {
+      if (maskTrk[GID::TPC] && nTracksTPCITSO2) {
+        const auto& match = recoCont.getTOFMatch(gid);
+        const auto& trkITSTPC = recoCont.getTPCITSTracks();
+        const auto tracksTPCITSO2 = trkITSTPC.data();
+        const auto& trkItsTPC = tracksTPCITSO2[match.getTrackIndex()];
+        if (retVal->tpcLinkTOF.size()) {
+          retVal->tpcLinkTOF[trkItsTPC.getRefTPC().getIndex()] = match.getTOFClIndex();
+        }
+        if (retVal->tpcLinkITS.size()) {
+          retVal->tpcLinkITS[trkItsTPC.getRefTPC().getIndex()] = trkItsTPC.getRefITS().getIndex();
+        }
+      }
+    } else if constexpr (isTPCTrack<decltype(trk)>()) {
+      time = trk.getTime0();
+    } else if constexpr (isTPCITSTrack<decltype(trk)>()) {
+      if (maskTrk[GID::TPC] && retVal->tpcLinkITS.size()) {
+        retVal->tpcLinkITS[trk.getRefTPC().getIndex()] = trk.getRefITS().getIndex();
+      }
+    } else if constexpr (isTPCTOFTrack<decltype(trk)>()) {
+      if (maskTrk[GID::TPC] && nTPCTOFMatches && retVal->tpcLinkTOF.size()) {
+        const auto& tpctofMatches = recoCont.getTPCTOFMatches();
+        const auto tpctofMatchesData = tpctofMatches.data();
+        const auto& match = tpctofMatchesData[trk.getRefMatch()];
+        retVal->tpcLinkTOF[match.getTrackIndex()] = match.getTOFClIndex();
+      }
+    }
+    if constexpr (std::is_base_of_v<o2::track::TrackParCov, std::decay_t<decltype(trk)>>) {
+      retVal->globalTracks.emplace_back(&trk);
+      retVal->globalTrackTimes.emplace_back(time);
+      return true;
+    } else {
+      return false;
+    }
+  };
+
+  recoCont.createTracksVariadic(creator);
+
+  if (maskTrk[GID::TPC] && retVal->tpcLinkTRD.size()) {
+    const auto& trdTracks = recoCont.getTPCTRDTracks<o2::trd::TrackTRD>();
+    const auto trdTracksTPCTRD = trdTracks.data();
+    const auto nTRDTracksTPCTRD = trdTracks.size();
+    for (unsigned int i = 0; i < nTRDTracksTPCTRD; i++) { // TODO: This should be handled by the createTracks logic, but so far it lacks the TRD tracks
+      retVal->tpcLinkTRD[trdTracksTPCTRD[i].getRefGlobalTrackId().getIndex()] = i;
+    }
+    if (nTracksTPCITSO2) {
+      const auto& trdTracks = recoCont.getITSTPCTRDTracks<o2::trd::TrackTRD>();
+      const auto trdTracksITSTPCTRD = trdTracks.data();
+
+      const auto& trkITSTPC = recoCont.getTPCITSTracks();
+      const auto tracksTPCITSO2 = trkITSTPC.data();
+
+      for (unsigned int i = 0; i < nTRDTracksITSTPCTRD; i++) {
+        retVal->tpcLinkTRD[tracksTPCITSO2[trdTracksITSTPCTRD[i].getRefGlobalTrackId().getIndex()].getRefTPC().getIndex()] = i | 0x40000000;
+      }
+    }
+  }
+
+  return std::move(retVal);
+}
diff --git a/EventVisualisation/Workflow/src/FileProducer.cxx b/EventVisualisation/Workflow/src/FileProducer.cxx
index f957dc0635877..c14a382b1ca55 100644
--- a/EventVisualisation/Workflow/src/FileProducer.cxx
+++ b/EventVisualisation/Workflow/src/FileProducer.cxx
@@ -14,6 +14,7 @@
 /// \author julian.myrcha@cern.ch
 
 #include "EveWorkflow/FileProducer.h"
+
 #include <deque>
 #include <iostream>
 #include <chrono>
@@ -22,6 +23,8 @@
 #include <algorithm>
 
 using namespace std;
+using namespace o2::event_visualisation;
+
 using std::cout;
 using std::endl;
 using std::chrono::duration_cast;
@@ -41,11 +44,12 @@ std::deque<std::string> FileProducer::load(const std::string& path)
   return result;
 }
 
-FileProducer::FileProducer(const std::string& path, const std::string& name, int filesInFolder)
+FileProducer::FileProducer(const std::string& path, int filesInFolder, const std::string& name)
 {
   this->mFilesInFolder = filesInFolder;
   this->mPath = path;
   this->mName = name;
+  std::filesystem::create_directories(this->mPath); // create folder if not exists (fails if no rights)
 }
 
 std::string FileProducer::newFileName() const
diff --git a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
index da5da2f63e504..13443f21a8963 100644
--- a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
+++ b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
@@ -9,40 +9,49 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+/// \file
+/// \author Julian Myrcha
+
 #include "EveWorkflow/O2DPLDisplay.h"
+#include "EveWorkflow/EveConfiguration.h"
 #include "EveWorkflow/FileProducer.h"
+#include "EveWorkflow/EveWorkflowHelper.h"
 #include "EventVisualisationDataConverter/VisualisationTrack.h"
 #include "EventVisualisationDataConverter/VisualisationEvent.h"
-#include "Framework/ConfigParamSpec.h"
+
+#include "DetectorsBase/GeometryManager.h"
 #include "DataFormatsParameters/GRPObject.h"
 #include "DataFormatsGlobalTracking/RecoContainer.h"
+#include "DataFormatsTPC/WorkflowHelper.h"
+#include "DataFormatsITSMFT/TopologyDictionary.h"
 #include "DetectorsCommonDataFormats/NameConf.h"
-#include "DetectorsBase/GeometryManager.h"
+#include "DetectorsBase/Propagator.h"
+#include "Framework/ConfigParamSpec.h"
+#include "GlobalTrackingWorkflowHelpers/InputHelper.h"
+#include "ITSBase/GeometryTGeo.h"
 #include "TRDBase/GeometryFlat.h"
-#include "TRDBase/Geometry.h"
 #include "TOFBase/Geo.h"
-#include "ITSBase/GeometryTGeo.h"
-#include "DetectorsBase/Propagator.h"
-#include "GPUO2InterfaceDisplay.h"
-#include "GPUO2InterfaceConfiguration.h"
 #include "TPCFastTransform.h"
-#include "TPCReconstruction/TPCFastTransformHelperO2.h"
-#include "GlobalTrackingWorkflowHelpers/InputHelper.h"
-#include "DataFormatsTPC/WorkflowHelper.h"
-#include "DataFormatsTRD/RecoInputContainer.h"
-#include "GPUWorkflowHelper/GPUWorkflowHelper.h"
-#include "DataFormatsITSMFT/TopologyDictionary.h"
+#include "TRDBase/Geometry.h"
+
+#include <unistd.h>
+#include <climits>
 
+using namespace o2::event_visualisation;
 using namespace o2::framework;
 using namespace o2::dataformats;
 using namespace o2::globaltracking;
-using namespace o2::gpu;
 using namespace o2::tpc;
 using namespace o2::trd;
 
 void customize(std::vector<ConfigParamSpec>& workflowOptions)
 {
   std::vector<o2::framework::ConfigParamSpec> options{
+    {"jsons-folder", VariantType::String, "jsons", {"name of the folder to store json files"}},
+    {"eve-hostname", VariantType::String, "", {"name of the host allowed to produce files (empty means no limit)"}},
+    {"number-of_files", VariantType::Int, 300, {"maximum number of json files in folder"}},
+    {"number-of_tracks", VariantType::Int, -1, {"maximum number of track stored in json file (-1 means no limit)"}},
+    {"time-interval", VariantType::Int, 5000, {"time interval in milliseconds between stored files"}},
     {"enable-mc", o2::framework::VariantType::Bool, false, {"enable visualization of MC data"}},
     {"disable-mc", o2::framework::VariantType::Bool, false, {"disable visualization of MC data"}}, // for compatibility, overrides enable-mc
     {"display-clusters", VariantType::String, "ITS,TPC,TRD,TOF", {"comma-separated list of clusters to display"}},
@@ -53,22 +62,18 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
 
   std::swap(workflowOptions, options);
 }
-
 #include "Framework/runDataProcessing.h"
 
-void O2GPUDPLDisplaySpec::init(InitContext& ic)
+void O2DPLDisplaySpec::init(InitContext& ic)
 {
   const auto grp = o2::parameters::GRPObject::loadFrom();
   o2::base::GeometryManager::loadGeometry();
   o2::base::Propagator::initFieldFromGRP();
-  mConfig.reset(new GPUO2InterfaceConfiguration);
+  mConfig.reset(new EveConfiguration);
   mConfig->configGRP.solenoidBz = 5.00668f * grp->getL3Current() / 30000.;
   mConfig->configGRP.continuousMaxTimeBin = grp->isDetContinuousReadOut(o2::detectors::DetID::TPC) ? -1 : 0; // Number of timebins in timeframe if continuous, 0 otherwise
   mConfig->ReadConfigurableParam();
 
-  mFastTransform = std::move(TPCFastTransformHelperO2::instance()->create(0));
-  mConfig->configCalib.fastTransform = mFastTransform.get();
-
   auto gm = o2::trd::Geometry::instance();
   gm->createPadPlaneArray();
   gm->createClusterMatrixArray();
@@ -77,26 +82,19 @@ void O2GPUDPLDisplaySpec::init(InitContext& ic)
 
   mITSDict = std::make_unique<o2::itsmft::TopologyDictionary>();
   mConfig->configCalib.itsPatternDict = mITSDict.get();
-
   mConfig->configProcessing.runMC = mUseMC;
 
   o2::tof::Geo::Init();
 
-  o2::its::GeometryTGeo::Instance()->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2GRot, o2::math_utils::TransformType::T2G, o2::math_utils::TransformType::L2G, o2::math_utils::TransformType::T2L));
-
-  //mDisplay.reset(new GPUO2InterfaceDisplay(mConfig.get()));
+  o2::its::GeometryTGeo::Instance()->fillMatrixCache(
+    o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2GRot,
+                             o2::math_utils::TransformType::T2G,
+                             o2::math_utils::TransformType::L2G,
+                             o2::math_utils::TransformType::T2L));
 }
 
-struct GPUWorkflowHelper::tmpDataContainer {
-  std::vector<o2::BaseCluster<float>> ITSClustersArray;
-  std::vector<int> tpcLinkITS, tpcLinkTRD, tpcLinkTOF;
-  std::vector<const o2::track::TrackParCov*> globalTracks;
-  std::vector<float> globalTrackTimes;
-};
-
 using GID = o2::dataformats::GlobalTrackID;
 using PNT = std::array<float, 3>;
-
 std::vector<PNT> getTrackPoints(const o2::track::TrackPar& trc, float minR, float maxR, float maxStep)
 
 {
@@ -132,17 +130,32 @@ std::vector<PNT> getTrackPoints(const o2::track::TrackPar& trc, float minR, floa
   return pnts;
 }
 
-void O2GPUDPLDisplaySpec::run(ProcessingContext& pc)
+void O2DPLDisplaySpec::run(ProcessingContext& pc)
 {
+  if (!this->mEveHostNameMatch) {
+    return;
+  }
+
+  // filtering out any run which occur before reaching next time interval
+  std::chrono::time_point<std::chrono::high_resolution_clock> currentTime = std::chrono::high_resolution_clock::now();
+  std::chrono::duration<double> elapsed = currentTime - this->mTimeStamp;
+  if (elapsed < this->mTimeInteval) {
+    return; // skip this run - it is too often
+  }
+  this->mTimeStamp = currentTime;
+
   o2::globaltracking::RecoContainer recoData;
   recoData.collectData(pc, *mDataRequest);
-  GPUTrackingInOutPointers ptrs;
-  auto cnt = GPUWorkflowHelper::fillIOPtr(ptrs, recoData, mUseMC, &(mConfig->configCalib), mClMask, mTrkMask, mTrkMask);
+  auto cnt = EveWorkflowHelper::compute(recoData, &(mConfig->configCalib), mClMask, mTrkMask, mTrkMask);
 
   std::cout << cnt->globalTracks.size() << std::endl;
   o2::event_visualisation::VisualisationEvent vEvent;
+  int trackCount = cnt->globalTracks.size(); // how many tracks should be stored
+  if (this->mNumberOfTracks != -1 && this->mNumberOfTracks < trackCount) {
+    trackCount = this->mNumberOfTracks; // less than available
+  }
 
-  for (int i = 0; i < cnt->globalTracks.size(); i++) {
+  for (unsigned int i = 0; i < trackCount; i++) {
     auto tr = cnt->globalTracks[i];
     std::cout << tr->getX() << std::endl;
     float rMax = 385;
@@ -170,11 +183,11 @@ void O2GPUDPLDisplaySpec::run(ProcessingContext& pc)
     }
   }
 
-  FileProducer producer("./jsons");
+  FileProducer producer(this->mJsonPath, this->mNumberOfFiles);
   vEvent.toFile(producer.newFileName());
 }
 
-void O2GPUDPLDisplaySpec::endOfStream(EndOfStreamContext& ec)
+void O2DPLDisplaySpec::endOfStream(EndOfStreamContext& ec)
 {
 }
 
@@ -183,8 +196,17 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   WorkflowSpec specs;
 
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
-
   bool useMC = cfgc.options().get<bool>("enable-mc") && !cfgc.options().get<bool>("disable-mc");
+  std::string jsonFolder = cfgc.options().get<std::string>("jsons-folder");
+  std::string eveHostName = cfgc.options().get<std::string>("eve-hostname");
+  char hostname[HOST_NAME_MAX];
+  gethostname(hostname, HOST_NAME_MAX);
+  bool eveHostNameMatch = eveHostName.empty() || eveHostName == hostname;
+
+  std::chrono::milliseconds timeInterval(cfgc.options().get<int>("time-interval"));
+  int numberOfFiles = cfgc.options().get<int>("number-of_files");
+  int numberOfTracks = cfgc.options().get<int>("number-of_tracks");
+
   GlobalTrackID::mask_t srcTrk = GlobalTrackID::getSourcesMask(cfgc.options().get<std::string>("display-tracks"));
   GlobalTrackID::mask_t srcCl = GlobalTrackID::getSourcesMask(cfgc.options().get<std::string>("display-clusters"));
   if (!srcTrk.any() && !srcCl.any()) {
@@ -199,10 +221,10 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   }
 
   specs.emplace_back(DataProcessorSpec{
-    "o2-gpu-display",
+    "o2-eve-display",
     dataRequest->inputs,
     {},
-    AlgorithmSpec{adaptFromTask<O2GPUDPLDisplaySpec>(useMC, srcTrk, srcCl, dataRequest)}});
+    AlgorithmSpec{adaptFromTask<O2DPLDisplaySpec>(useMC, srcTrk, srcCl, dataRequest, jsonFolder, timeInterval, numberOfFiles, numberOfTracks, eveHostNameMatch)}});
 
   return std::move(specs);
 }