diff --git a/Modules/Simulation/CMakeLists.txt b/Modules/Simulation/CMakeLists.txt
index 55e9c80660..78ebb99392 100644
--- a/Modules/Simulation/CMakeLists.txt
+++ b/Modules/Simulation/CMakeLists.txt
@@ -1,11 +1,11 @@
 if(MITK_USE_SOFA)
   MITK_CREATE_MODULE(
-    DEPENDS MitkCore
+    DEPENDS MitkSceneSerializationBase
     PACKAGE_DEPENDS Boost GLUT GLEW SOFA
   )
 
   if(MSVC)
     list(APPEND module_compile_flags /wd4250 4251 4267 4275)
     set_target_properties(${MODULE_TARGET} PROPERTIES COMPILE_FLAGS "${module_compile_flags}")
   endif()
 endif()
diff --git a/Modules/Simulation/files.cmake b/Modules/Simulation/files.cmake
index d106dec8b4..ce3867b459 100644
--- a/Modules/Simulation/files.cmake
+++ b/Modules/Simulation/files.cmake
@@ -1,15 +1,18 @@
 set(CPP_FILES
   mitkGetSimulationService.cpp
   mitkIndexROI.cpp
   mitkISimulationService.cpp
   mitkSetVtkRendererVisitor.cpp
   mitkSimulation.cpp
   mitkSimulationActivator.cpp
   mitkSimulationIOFactory.cpp
   mitkSimulationObjectFactory.cpp
   mitkSimulationReader.cpp
+  mitkSimulationSerializer.cpp
   mitkSimulationService.cpp
   mitkSimulationVtkMapper3D.cpp
+  mitkSimulationWriter.cpp
+  mitkSimulationWriterFactory.cpp
   mitkVtkModel.cpp
   mitkVtkSimulationPolyDataMapper.cpp
 )
diff --git a/Modules/Simulation/mitkSimulationObjectFactory.cpp b/Modules/Simulation/mitkSimulationObjectFactory.cpp
index f1bbee1116..572949610d 100644
--- a/Modules/Simulation/mitkSimulationObjectFactory.cpp
+++ b/Modules/Simulation/mitkSimulationObjectFactory.cpp
@@ -1,135 +1,140 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkIndexROI.h"
 #include "mitkSimulation.h"
 #include "mitkSimulationObjectFactory.h"
 #include "mitkSimulationVtkMapper3D.h"
+#include "mitkSimulationWriter.h"
 #include "mitkVtkModel.h"
 #include <mitkCoreObjectFactory.h>
 #include <sofa/helper/system/glut.h>
 #include <sofa/component/init.h>
 #include <sofa/core/ObjectFactory.h>
 #include <sofa/simulation/common/xml/initXml.h>
 
 static void InitializeSofa()
 {
   int argc = 0;
   glutInit(&argc, NULL);
 
   sofa::component::init();
   sofa::simulation::xml::initXml();
 }
 
 static void RegisterSofaClasses()
 {
   using sofa::core::ObjectFactory;
   using sofa::core::RegisterObject;
 
   int IndexROIClass = RegisterObject("").add<mitk::IndexROI>();
   int VtkModelClass = RegisterObject("").add<mitk::VtkModel>();
 
   ObjectFactory::AddAlias("VisualModel", "VtkModel", true);
   ObjectFactory::AddAlias("OglModel", "VtkModel", true);
 }
 
 mitk::SimulationObjectFactory::SimulationObjectFactory()
-  : m_SimulationIOFactory(SimulationIOFactory::New())
+  : m_SimulationIOFactory(SimulationIOFactory::New()),
+    m_SimulationWriterFactory(SimulationWriterFactory::New())
 {
   itk::ObjectFactoryBase::RegisterFactory(m_SimulationIOFactory);
+  itk::ObjectFactoryBase::RegisterFactory(m_SimulationWriterFactory);
+
+  m_FileWriters.push_back(SimulationWriter::New().GetPointer());
 
   std::string description = "SOFA Scene Files";
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.scn", description));
-  m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.xml", description));
 
   InitializeSofa();
   RegisterSofaClasses();
 }
 
 mitk::SimulationObjectFactory::~SimulationObjectFactory()
 {
+  itk::ObjectFactoryBase::UnRegisterFactory(m_SimulationWriterFactory);
   itk::ObjectFactoryBase::UnRegisterFactory(m_SimulationIOFactory);
 }
 
 mitk::Mapper::Pointer mitk::SimulationObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId slotId)
 {
   Mapper::Pointer mapper;
 
   if (dynamic_cast<Simulation*>(node->GetData()) != NULL)
   {
     if (slotId == BaseRenderer::Standard3D)
       mapper = mitk::SimulationVtkMapper3D::New();
 
     if (mapper.IsNotNull())
       mapper->SetDataNode(node);
   }
 
   return mapper;
 }
 
 const char* mitk::SimulationObjectFactory::GetDescription() const
 {
   return "Simulation Object Factory";
 }
 
 const char* mitk::SimulationObjectFactory::GetFileExtensions()
 {
   std::string fileExtensions;
   this->CreateFileExtensions(m_FileExtensionsMap, fileExtensions);
   return fileExtensions.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::SimulationObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 const char* mitk::SimulationObjectFactory::GetITKSourceVersion() const
 {
   return ITK_SOURCE_VERSION;
 }
 
 const char* mitk::SimulationObjectFactory::GetSaveFileExtensions()
 {
   std::string saveFileExtensions;
   this->CreateFileExtensions(m_FileExtensionsMap, saveFileExtensions);
   return saveFileExtensions.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::SimulationObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::SimulationObjectFactory::SetDefaultProperties(mitk::DataNode* node)
 {
   if (node == NULL)
     return;
 
   if (dynamic_cast<Simulation*>(node->GetData()) != NULL)
     SimulationVtkMapper3D::SetDefaultProperties(node);
 }
 
 void mitk::RegisterSimulationObjectFactory()
 {
   static bool alreadyRegistered = false;
 
   if (!alreadyRegistered)
   {
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(mitk::SimulationObjectFactory::New());
     alreadyRegistered = true;
   }
 }
diff --git a/Modules/Simulation/mitkSimulationObjectFactory.h b/Modules/Simulation/mitkSimulationObjectFactory.h
index c27cb57a43..49d4f23752 100644
--- a/Modules/Simulation/mitkSimulationObjectFactory.h
+++ b/Modules/Simulation/mitkSimulationObjectFactory.h
@@ -1,52 +1,54 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef mitkSimulationObjectFactory_h
 #define mitkSimulationObjectFactory_h
 
 #include "mitkSimulationIOFactory.h"
+#include "mitkSimulationWriterFactory.h"
 #include <mitkCoreObjectFactoryBase.h>
 
 namespace mitk
 {
   class MitkSimulation_EXPORT SimulationObjectFactory : public CoreObjectFactoryBase
   {
   public:
     mitkClassMacro(SimulationObjectFactory, CoreObjectFactoryBase);
     itkFactorylessNewMacro(Self);
 
     Mapper::Pointer CreateMapper(DataNode* node, MapperSlotId slotId);
     const char* GetDescription() const;
     const char* GetFileExtensions();
     MultimapType GetFileExtensionsMap();
     const char* GetITKSourceVersion() const;
     const char* GetSaveFileExtensions();
     MultimapType GetSaveFileExtensionsMap();
     void SetDefaultProperties(DataNode* node);
 
   private:
     SimulationObjectFactory();
     ~SimulationObjectFactory();
 
     SimulationIOFactory::Pointer m_SimulationIOFactory;
+    SimulationWriterFactory::Pointer m_SimulationWriterFactory;
     MultimapType m_FileExtensionsMap;
     MultimapType m_SaveFileExtensionsMap;
   };
 
   MitkSimulation_EXPORT void RegisterSimulationObjectFactory();
 }
 
 #endif
diff --git a/Modules/Simulation/mitkSimulationReader.cpp b/Modules/Simulation/mitkSimulationReader.cpp
index 4b035bafef..644b504317 100644
--- a/Modules/Simulation/mitkSimulationReader.cpp
+++ b/Modules/Simulation/mitkSimulationReader.cpp
@@ -1,128 +1,133 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkGetSimulationService.h"
 #include "mitkISimulationService.h"
 #include "mitkSimulation.h"
 #include "mitkSimulationReader.h"
+#include <mitkStringProperty.h>
 #include <sofa/helper/system/SetDirectory.h>
 #include <algorithm>
 
 bool mitk::SimulationReader::CanReadFile(const std::string& filename, const std::string&, const std::string&)
 {
   std::string::size_type length = filename.length();
 
   if (length < 5)
     return false;
 
   std::string ext = filename.substr(length - 4);
   std::transform(ext.begin(), ext.end(), ext.begin(), tolower);
 
   if (ext == ".scn" || ext == ".xml")
     return true;
 
   return false;
 }
 
 mitk::SimulationReader::SimulationReader()
 {
   mitk::Simulation::Pointer output = mitk::Simulation::New();
 
   this->SetNumberOfRequiredOutputs(1);
   this->SetNthOutput(0, output.GetPointer());
 }
 
 mitk::SimulationReader::~SimulationReader()
 {
 }
 
 void mitk::SimulationReader::GenerateData()
 {
   Simulation::Pointer simulation = static_cast<mitk::Simulation*>(this->GetOutput());
   sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSimulation();
 
   ISimulationService* simulationService = GetSimulationService();
   Simulation::Pointer currentSimulation = simulationService->GetSimulation();
 
   simulationService->SetSimulation(simulation);
 
   std::string path = sofa::helper::system::SetDirectory::GetParentDir(m_FileName.c_str());
   sofa::helper::system::DataRepository.addFirstPath(path);
 
   sofa::simulation::Node::SPtr rootNode = sofa::core::objectmodel::SPtr_dynamic_cast<sofa::simulation::Node>(sofaSimulation->load(m_FileName.c_str()));
 
   if (!rootNode)
   {
     sofa::helper::system::DataRepository.removePath(path);
     mitkThrow() << "Could not load '" << m_FileName << "'!";
   }
 
   simulation->SetRootNode(rootNode);
 
+  std::ifstream scnFile(m_FileName.c_str());
+  simulation->SetProperty("Scene File", StringProperty::New(std::string((std::istreambuf_iterator<char>(scnFile)), std::istreambuf_iterator<char>())));
+  scnFile.close();
+
   sofaSimulation->init(rootNode.get());
   sofaSimulation->reset(rootNode.get());
   simulation->UpdateOutputInformation();
 
   sofa::helper::system::DataRepository.removePath(path);
 
   simulationService->SetSimulation(currentSimulation);
 }
 
 void mitk::SimulationReader::GenerateOutputInformation()
 {
 }
 
 const char* mitk::SimulationReader::GetFileName() const
 {
   return m_FileName.c_str();
 }
 
 void mitk::SimulationReader::SetFileName(const char* aFileName)
 {
   m_FileName = aFileName;
 }
 
 const char* mitk::SimulationReader::GetFilePattern() const
 {
   return m_FilePattern.c_str();
 }
 
 void mitk::SimulationReader::SetFilePattern(const char* aFilePattern)
 {
   m_FilePattern = aFilePattern;
 }
 
 const char* mitk::SimulationReader::GetFilePrefix() const
 {
   return m_FilePrefix.c_str();
 }
 
 void mitk::SimulationReader::SetFilePrefix(const char* aFilePrefix)
 {
   m_FilePrefix = aFilePrefix;
 }
 
 mitk::BaseDataSource::DataObjectPointer mitk::SimulationReader::MakeOutput(DataObjectPointerArraySizeType)
 {
   return mitk::Simulation::New().GetPointer();
 }
 
 mitk::BaseDataSource::DataObjectPointer mitk::SimulationReader::MakeOutput(const DataObjectIdentifierType& name)
 {
   return this->IsIndexedOutputName(name)
     ? this->MakeOutput(this->MakeIndexFromOutputName(name))
     : mitk::Simulation::New().GetPointer();
 }
diff --git a/Modules/Simulation/mitkSimulationSerializer.cpp b/Modules/Simulation/mitkSimulationSerializer.cpp
new file mode 100644
index 0000000000..d68fa48fa8
--- /dev/null
+++ b/Modules/Simulation/mitkSimulationSerializer.cpp
@@ -0,0 +1,61 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkSimulation.h"
+#include "mitkSimulationSerializer.h"
+#include "mitkSimulationWriter.h"
+
+MITK_REGISTER_SERIALIZER(SimulationSerializer)
+
+mitk::SimulationSerializer::SimulationSerializer()
+{
+}
+
+mitk::SimulationSerializer::~SimulationSerializer()
+{
+}
+
+std::string mitk::SimulationSerializer::Serialize()
+{
+  const Simulation* simulation = dynamic_cast<const Simulation*>(m_Data.GetPointer());
+
+  if (simulation == NULL)
+  {
+    MITK_ERROR << " Invalid simulation object cannot be serialized!";
+    return "";
+  }
+
+  std::string filename(this->GetUniqueFilenameInWorkingDirectory());
+  filename += "_" + m_FilenameHint + ".scn";
+
+  std::string fullPath = m_WorkingDirectory;
+  fullPath += "/" + filename;
+
+  try
+  {
+    SimulationWriter::Pointer writer = SimulationWriter::New();
+    writer->SetFileName(fullPath.c_str());
+    writer->SetInput(const_cast<Simulation*>(simulation));
+    writer->Write();
+  }
+  catch (const std::exception& e)
+  {
+    MITK_ERROR << " Error serializing simulation object to " << fullPath << ": " << e.what();
+    return "";
+  }
+
+  return filename;
+}
diff --git a/Modules/Simulation/mitkSimulationSerializer.h b/Modules/Simulation/mitkSimulationSerializer.h
new file mode 100644
index 0000000000..1b6b573c1c
--- /dev/null
+++ b/Modules/Simulation/mitkSimulationSerializer.h
@@ -0,0 +1,40 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkSimulationSerializer_h
+#define mitkSimulationSerializer_h
+
+#include <mitkBaseDataSerializer.h>
+#include <MitkSimulationExports.h>
+
+namespace mitk
+{
+  class MitkSimulation_EXPORT SimulationSerializer : public BaseDataSerializer
+  {
+  public:
+    mitkClassMacro(SimulationSerializer, BaseDataSerializer);
+    itkFactorylessNewMacro(Self);
+    itkCloneMacro(Self);
+
+    std::string Serialize();
+
+  protected:
+    SimulationSerializer();
+    ~SimulationSerializer();
+  };
+}
+
+#endif
diff --git a/Modules/Simulation/mitkSimulationWriter.cpp b/Modules/Simulation/mitkSimulationWriter.cpp
new file mode 100644
index 0000000000..f719a99bae
--- /dev/null
+++ b/Modules/Simulation/mitkSimulationWriter.cpp
@@ -0,0 +1,148 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include <mitkExceptionMacro.h>
+#include <mitkStringProperty.h>
+#include "mitkSimulation.h"
+#include "mitkSimulationWriter.h"
+
+mitk::SimulationWriter::SimulationWriter()
+  : m_FileExtension(".scn"),
+    m_MIMEType("application/xml")
+{
+  this->SetNumberOfRequiredInputs(1);
+  this->SetNumberOfIndexedOutputs(0);
+}
+
+mitk::SimulationWriter::~SimulationWriter()
+{
+}
+
+void mitk::SimulationWriter::GenerateData()
+{
+  if (m_FileName.empty())
+    mitkThrow() << "Filename is empty!";
+
+  Simulation* simulation = dynamic_cast<Simulation*>(this->GetInput(0));
+
+  if (simulation == NULL)
+    mitkThrow() << "Invalid input!";
+
+  std::ofstream scnFile(m_FileName.c_str());
+  scnFile << simulation->GetProperty("Scene File")->GetValueAsString();
+}
+
+mitk::Simulation* mitk::SimulationWriter::GetInput()
+{
+  if (this->GetNumberOfInputs() == 0)
+    return NULL;
+
+  return dynamic_cast<Simulation*>(this->GetInput(0));
+}
+
+void mitk::SimulationWriter::SetInput(Simulation *simulation)
+{
+  this->SetNthInput(0, simulation);
+}
+
+const char* mitk::SimulationWriter::GetFileName() const
+{
+  return m_FileName.c_str();
+}
+
+void mitk::SimulationWriter::SetFileName(const char* fileName)
+{
+  m_FileName = fileName;
+}
+
+const char* mitk::SimulationWriter::GetFilePrefix() const
+{
+  return m_FilePrefix.c_str();
+}
+
+void mitk::SimulationWriter::SetFilePrefix(const char* filePrefix)
+{
+  m_FilePrefix = filePrefix;
+}
+
+const char* mitk::SimulationWriter::GetFilePattern() const
+{
+  return m_FilePattern.c_str();
+}
+
+void mitk::SimulationWriter::SetFilePattern(const char* filePattern)
+{
+  m_FilePattern = filePattern;
+}
+
+std::string mitk::SimulationWriter::GetFileExtension()
+{
+  return m_FileExtension;
+}
+
+std::vector<std::string> mitk::SimulationWriter::GetPossibleFileExtensions()
+{
+  std::vector<std::string> possibleFileExtensions;
+  possibleFileExtensions.push_back(m_FileExtension);
+  return possibleFileExtensions;
+}
+
+std::string mitk::SimulationWriter::GetWritenMIMEType()
+{
+  return m_MIMEType;
+}
+
+bool mitk::SimulationWriter::CanWriteDataType(DataNode* dataNode)
+{
+  if (dataNode == NULL)
+    return false;
+
+  return this->CanWriteBaseDataType(dataNode->GetData());
+}
+
+const char* mitk::SimulationWriter::GetDefaultFilename()
+{
+  std::string defaultFilename = "Simulation" + m_FileExtension;
+  return defaultFilename.c_str();
+}
+
+const char* mitk::SimulationWriter::GetFileDialogPattern()
+{
+  std::string fileDialogPattern = "SOFA Scene Files (*" + m_FileExtension + ")";
+  return fileDialogPattern.c_str();
+}
+
+const char* mitk::SimulationWriter::GetDefaultExtension()
+{
+  return m_FileExtension.c_str();
+}
+
+bool mitk::SimulationWriter::CanWriteBaseDataType(BaseData::Pointer data)
+{
+  if (data.IsNull())
+    return false;
+
+  return dynamic_cast<mitk::Simulation*>(data.GetPointer()) != NULL;
+}
+
+void mitk::SimulationWriter::DoWrite(BaseData::Pointer data)
+{
+  if (this->CanWriteBaseDataType(data))
+  {
+    this->SetNthInput(0, dynamic_cast<itk::DataObject*>(data.GetPointer()));
+    this->Update();
+  }
+}
diff --git a/Modules/Simulation/mitkSimulationWriter.h b/Modules/Simulation/mitkSimulationWriter.h
new file mode 100644
index 0000000000..b94aa4e4be
--- /dev/null
+++ b/Modules/Simulation/mitkSimulationWriter.h
@@ -0,0 +1,77 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkSimulationWriter_h
+#define mitkSimulationWriter_h
+
+#include <mitkFileWriterWithInformation.h>
+#include <MitkSimulationExports.h>
+
+namespace mitk
+{
+  class Simulation;
+
+  class MitkSimulation_EXPORT SimulationWriter : public FileWriterWithInformation
+  {
+  public:
+    mitkClassMacro(SimulationWriter, FileWriterWithInformation);
+    itkFactorylessNewMacro(Self);
+    itkCloneMacro(Self);
+
+    using Superclass::SetInput;
+    void SetInput(Simulation* simulation);
+
+    // mitk::FileWriter interface
+
+    mitkWriterMacro;
+    using Superclass::GetInput;
+    Simulation* GetInput();
+
+    const char* GetFileName() const;
+    void SetFileName(const char* fileName);
+    const char* GetFilePrefix() const;
+    void SetFilePrefix(const char* filePrefix);
+    const char* GetFilePattern() const;
+    void SetFilePattern(const char* filePattern);
+    std::string GetFileExtension();
+    std::vector<std::string> GetPossibleFileExtensions();
+    std::string GetWritenMIMEType();
+    bool CanWriteDataType(DataNode* dataNode);
+
+    // mitk::FileWriterWithInformation interface
+
+    const char* GetDefaultFilename();
+    const char* GetFileDialogPattern();
+    const char* GetDefaultExtension();
+    bool CanWriteBaseDataType(BaseData::Pointer data);
+    void DoWrite(BaseData::Pointer data);
+
+  protected:
+    SimulationWriter();
+    ~SimulationWriter();
+
+    void GenerateData();
+
+  private:
+    std::string m_FileName;
+    std::string m_FilePrefix;
+    std::string m_FilePattern;
+    std::string m_FileExtension;
+    std::string m_MIMEType;
+  };
+}
+
+#endif
diff --git a/Modules/Simulation/mitkSimulationWriterFactory.cpp b/Modules/Simulation/mitkSimulationWriterFactory.cpp
new file mode 100644
index 0000000000..a5111ca7ba
--- /dev/null
+++ b/Modules/Simulation/mitkSimulationWriterFactory.cpp
@@ -0,0 +1,76 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkSimulationWriterFactory.h"
+#include <itkVersion.h>
+#include <mitkSimulationWriter.h>
+
+namespace mitk
+{
+  template <class T>
+  class CreateSimulationWriterFunction : public itk::CreateObjectFunctionBase
+  {
+  public:
+    mitkClassMacro(CreateSimulationWriterFunction, itk::CreateObjectFunctionBase);
+    itkFactorylessNewMacro(Self);
+
+    itk::LightObject::Pointer CreateObject()
+    {
+      typename T::Pointer simulationWriter = T::New();
+      simulationWriter->Register();
+      return simulationWriter.GetPointer();
+    }
+
+  protected:
+    CreateSimulationWriterFunction()
+    {
+    }
+
+    ~CreateSimulationWriterFunction()
+    {
+    }
+  };
+}
+
+mitk::SimulationWriterFactory::SimulationWriterFactory()
+{
+  this->RegisterOverride(
+    "IOWriter",
+    "SimulationWriter",
+    "SOFA scene file writer",
+    true,
+    CreateSimulationWriterFunction<SimulationWriter>::New());
+}
+
+mitk::SimulationWriterFactory::~SimulationWriterFactory()
+{
+}
+
+const char* mitk::SimulationWriterFactory::GetITKSourceVersion() const
+{
+  return ITK_SOURCE_VERSION;
+}
+
+const char* mitk::SimulationWriterFactory::GetDescription() const
+{
+  return "SimulationWriterFactory";
+}
+
+/*itk::ObjectFactoryBase::Pointer mitk::SimulationWriterFactory::GetInstance()
+{
+  static SimulationWriterFactory::Pointer factory = SimulationWriterFactory::New();
+  return factory.GetPointer();
+}*/
diff --git a/Modules/Simulation/mitkSimulationWriterFactory.h b/Modules/Simulation/mitkSimulationWriterFactory.h
new file mode 100644
index 0000000000..d420790d59
--- /dev/null
+++ b/Modules/Simulation/mitkSimulationWriterFactory.h
@@ -0,0 +1,44 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkSimulationWriterFactory_h
+#define mitkSimulationWriterFactory_h
+
+#include <itkObjectFactoryBase.h>
+#include <mitkCommon.h>
+#include <MitkSimulationExports.h>
+
+namespace mitk
+{
+  class MitkSimulation_EXPORT SimulationWriterFactory : public itk::ObjectFactoryBase
+  {
+  public:
+    mitkClassMacro(SimulationWriterFactory, itk::ObjectFactoryBase);
+    itkFactorylessNewMacro(Self);
+
+    const char* GetITKSourceVersion() const;
+    const char* GetDescription() const;
+
+  protected:
+    SimulationWriterFactory();
+    ~SimulationWriterFactory();
+
+  private:
+    // static itk::ObjectFactoryBase::Pointer GetInstance();
+  };
+}
+
+#endif