diff --git a/CMake/cmake_config_files/ELLADAN.config.cmake b/CMake/cmake_config_files/ELLADAN.config.cmake
index 1a7304ce91bd3534660b6e056cb1092481b2bc14..3729898e3b9f105232db5d8552fbb9e87c85e2d3 100644
--- a/CMake/cmake_config_files/ELLADAN.config.cmake
+++ b/CMake/cmake_config_files/ELLADAN.config.cmake
@@ -42,4 +42,6 @@ IF(${USE_METIS})
     SET(METIS_DEBUG_LIBRARY "/usr/lib/x86_64-linux-gnu/libmetis.so")
     SET(METIS_RELEASE_LIBRARY "/usr/lib/x86_64-linux-gnu/libmetis.so")
 ENDIF()
-#set(SOURCE_ROOT "/host/Projects/pFluid/source")
\ No newline at end of file
+#set(SOURCE_ROOT "/host/Projects/pFluid/source")
+
+SET(GMOCK_ROOT /usr/src/googletest CACHE PATH "GMOCK ROOT")
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7edb2acb24e38011d7d4c35242df8c98daeff66b..6c3a3d33f78b5a886a54d80960ed67cc1f69d208 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -28,5 +28,3 @@ add_subdirectory(src/basics)
 include (gpu.cmake)
 #endif()
 
-set (APPS_ROOT_CPU "${CMAKE_SOURCE_DIR}/apps/cpu/")
-#include(${APPS_ROOT_CPU}/Applications.cmake)
\ No newline at end of file
diff --git a/apps/gpu/LBM/TrafficTest/CMakeLists.txt b/apps/gpu/LBM/TrafficTest/CMakeLists.txt
index 15efc435033ecade76ad4895459590c39e031adc..9503271f88ded591c3d9e8c12666b65c99780f91 100644
--- a/apps/gpu/LBM/TrafficTest/CMakeLists.txt
+++ b/apps/gpu/LBM/TrafficTest/CMakeLists.txt
@@ -6,7 +6,7 @@ set(includeDirectories "${CMAKE_SOURCE_DIR}/src"
 
 
 
-vf_add_library(BUILDTYPE binary DEPENDS Traffic)
+vf_add_library(BUILDTYPE binary DEPENDS Traffic basics GridGenerator)
 
 vf_get_library_name(library_name)
 target_include_directories(${library_name} PRIVATE "${CMAKE_SOURCE_DIR}/src/basics")
diff --git a/cpu.cmake b/cpu.cmake
index 98d408952546ded61c69b21d1c1b5723099be9f9..73ef81464b8a4bf14c802f04ba718f54f26afeaa 100644
--- a/cpu.cmake
+++ b/cpu.cmake
@@ -164,5 +164,5 @@ add_subdirectory(3rdParty/MuParser)
 add_subdirectory(src/cpu/VirtualFluidsCore)
 #add_subdirectory(VirtualFluidsBasic)
 
-#set(APPS_ROOT "${SOURCE_ROOT}/cpu/Applications")
-#INCLUDE(${APPS_ROOT}/Applications.cmake)
\ No newline at end of file
+set (APPS_ROOT_CPU "${CMAKE_SOURCE_DIR}/apps/cpu/")
+include(${APPS_ROOT_CPU}/Applications.cmake)
\ No newline at end of file
diff --git a/src/gpu/GridGenerator/CMakeLists.txt b/src/gpu/GridGenerator/CMakeLists.txt
index 9e10f8bf022754e00129311a9748cd0acaf2f29b..7ec3d01d871944022e73d5064f0352958014836a 100644
--- a/src/gpu/GridGenerator/CMakeLists.txt
+++ b/src/gpu/GridGenerator/CMakeLists.txt
@@ -12,7 +12,7 @@
 #linkOpenMP(${targetName})
 
 
-vf_add_library(BUILDTYPE shared)
+vf_add_library(BUILDTYPE shared DEPENDS basics)
 
 include (${CMAKE_PATH}/3rd/cuda.cmake)
 include (${CMAKE_PATH}/3rd/OpenMP.cmake)
diff --git a/src/gpu/GridGenerator/StreetPointFinder/JunctionReader.h b/src/gpu/GridGenerator/StreetPointFinder/JunctionReader.h
index 5d59f2d337435e0ee198ed6e0df227957702a6ef..7d7d2bbb1359c728c99d00304497c5ef5fc60596 100644
--- a/src/gpu/GridGenerator/StreetPointFinder/JunctionReader.h
+++ b/src/gpu/GridGenerator/StreetPointFinder/JunctionReader.h
@@ -3,6 +3,8 @@
 
 #include <vector>
 
+#include "GridGenerator_export.h"
+
 #include "Core/DataTypes.h"
 #include "Core/Logger/Logger.h"
 
@@ -10,7 +12,7 @@
 
 #include <VirtualFluidsDefinitions.h>
 
-struct VIRTUALFLUIDS_GPU_EXPORT JunctionReaderData
+struct GRIDGENERATOR_EXPORT JunctionReaderData
 {
 	std::vector<uint> inCells;
 	std::vector<uint> outCells;
@@ -21,7 +23,7 @@ struct VIRTUALFLUIDS_GPU_EXPORT JunctionReaderData
 };
 
 
-struct VIRTUALFLUIDS_GPU_EXPORT Neighbors
+struct GRIDGENERATOR_EXPORT Neighbors
 {
 	std::vector<int> cells;
 	std::vector<int> neighbors;
@@ -29,7 +31,7 @@ struct VIRTUALFLUIDS_GPU_EXPORT Neighbors
 
 
 
-struct VIRTUALFLUIDS_GPU_EXPORT JunctionReader
+struct GRIDGENERATOR_EXPORT JunctionReader
 {
 	std::vector<JunctionReaderData> junctions;
 	Neighbors specialNeighbors;
diff --git a/src/gpu/GridGenerator/StreetPointFinder/SinkReader.h b/src/gpu/GridGenerator/StreetPointFinder/SinkReader.h
index 0e1d851ba2753bab13d33ce5a11cbd28b0822924..d6f71f4b5f05d2c5e1d387d3462324aa90cdb03f 100644
--- a/src/gpu/GridGenerator/StreetPointFinder/SinkReader.h
+++ b/src/gpu/GridGenerator/StreetPointFinder/SinkReader.h
@@ -3,6 +3,8 @@
 
 #include <vector>
 
+#include "GridGenerator_export.h"
+
 #include "Core/DataTypes.h"
 #include "Core/Logger/Logger.h"
 
@@ -10,13 +12,13 @@
 
 #include <VirtualFluidsDefinitions.h>
 
-struct VIRTUALFLUIDS_GPU_EXPORT SinkReaderData{
+struct GRIDGENERATOR_EXPORT SinkReaderData{
 	uint sinkIndex;
 	float sinkBlockedPossibility;
 	SinkReaderData(uint sinkIndex, float sinkBlockedPossibility);
 };
 
-struct VIRTUALFLUIDS_GPU_EXPORT SinkReader
+struct GRIDGENERATOR_EXPORT SinkReader
 {
 	std::vector<SinkReaderData> sinks;
 	StreetPointFinder* streetPointFinder;
diff --git a/src/gpu/GridGenerator/StreetPointFinder/SourceReader.h b/src/gpu/GridGenerator/StreetPointFinder/SourceReader.h
index 79aa6681d0a578194c4d6c9ae8991fa2beab0aa9..4ada88fb80ae8bc967aa99c86231f60525115bbb 100644
--- a/src/gpu/GridGenerator/StreetPointFinder/SourceReader.h
+++ b/src/gpu/GridGenerator/StreetPointFinder/SourceReader.h
@@ -10,13 +10,13 @@
 
 #include <VirtualFluidsDefinitions.h>
 
-struct VIRTUALFLUIDS_GPU_EXPORT SourceReaderData {
+struct GRIDGENERATOR_EXPORT SourceReaderData {
 	unsigned int sourceIndex;
 	float sourcePossibility;
 	SourceReaderData(unsigned int sourceIndex, float sourcePossibility);
 };
 
-struct VIRTUALFLUIDS_GPU_EXPORT SourceReader
+struct GRIDGENERATOR_EXPORT SourceReader
 {
 	std::vector<SourceReaderData> sources;
 	StreetPointFinder* streetPointFinder;
diff --git a/src/gpu/GridGenerator/StreetPointFinder/StreetPointFinder.h b/src/gpu/GridGenerator/StreetPointFinder/StreetPointFinder.h
index 82a169f60135f685668741f215cf1f53d301e4a9..905ac7b2ff1907910663622123e57ac479a4679d 100644
--- a/src/gpu/GridGenerator/StreetPointFinder/StreetPointFinder.h
+++ b/src/gpu/GridGenerator/StreetPointFinder/StreetPointFinder.h
@@ -4,6 +4,8 @@
 #include <vector>
 #include <string>
 
+#include "GridGenerator_export.h"
+
 #include "Core/PointerDefinitions.h"
 #include "Core/DataTypes.h"
 
@@ -11,7 +13,7 @@
 
 class Grid;
 
-struct VIRTUALFLUIDS_GPU_EXPORT Street
+struct GRIDGENERATOR_EXPORT Street
 {
     // The start and end coordinates are stored for cell centers!
     //
@@ -39,7 +41,7 @@ struct VIRTUALFLUIDS_GPU_EXPORT Street
     void findIndicesLB( SPtr<Grid> grid, real initialSearchHeight);
 };
 
-struct VIRTUALFLUIDS_GPU_EXPORT StreetPointFinder
+struct GRIDGENERATOR_EXPORT StreetPointFinder
 {
     std::vector<Street> streets;
 
diff --git a/src/gpu/GridGenerator/geometries/Arrow/ArrowImp.h b/src/gpu/GridGenerator/geometries/Arrow/ArrowImp.h
index dccb9b9e24c35c465ff31bfd3ed56ff2ed8d226e..195223d9125c265905b6c47ee8dc09edb205f267 100644
--- a/src/gpu/GridGenerator/geometries/Arrow/ArrowImp.h
+++ b/src/gpu/GridGenerator/geometries/Arrow/ArrowImp.h
@@ -4,6 +4,7 @@
 #include <memory>
 
 #include "global.h"
+#include "GridGenerator_export.h"
 
 #include "Arrow.h"
 
@@ -12,13 +13,13 @@ struct Vertex;
 class ArrowImp : public Arrow 
 {
 public:
-	VIRTUALFLUIDS_GPU_EXPORT virtual ~ArrowImp();
-	VIRTUALFLUIDS_GPU_EXPORT static std::shared_ptr<Arrow> make(const Vertex &start, const Vertex &end);
+	GRIDGENERATOR_EXPORT virtual ~ArrowImp();
+	GRIDGENERATOR_EXPORT static std::shared_ptr<Arrow> make(const Vertex &start, const Vertex &end);
 
-	VIRTUALFLUIDS_GPU_EXPORT std::shared_ptr<Vertex> getStart() const;
-	VIRTUALFLUIDS_GPU_EXPORT std::shared_ptr<Vertex> getEnd() const;
+	GRIDGENERATOR_EXPORT std::shared_ptr<Vertex> getStart() const;
+	GRIDGENERATOR_EXPORT std::shared_ptr<Vertex> getEnd() const;
 
-	VIRTUALFLUIDS_GPU_EXPORT void print() const;
+	GRIDGENERATOR_EXPORT void print() const;
 private:
 	ArrowImp(const Vertex &start, const Vertex &end);
 
diff --git a/src/gpu/GridGenerator/geometries/BoundingBox/BoundingBox.h b/src/gpu/GridGenerator/geometries/BoundingBox/BoundingBox.h
index 3c5946ae41c2d4b60b33f2a3e665c4e317896937..e1d4f24e450400154498f716bd1fa4042be795f6 100644
--- a/src/gpu/GridGenerator/geometries/BoundingBox/BoundingBox.h
+++ b/src/gpu/GridGenerator/geometries/BoundingBox/BoundingBox.h
@@ -3,14 +3,14 @@
 
 #include <vector>
 #include <cuda_runtime.h>
-
+#include "GridGenerator_export.h"
 #include "global.h"
 
 struct Vertex;
 struct Triangle;
 
 
-class VIRTUALFLUIDS_GPU_EXPORT BoundingBox
+class GRIDGENERATOR_EXPORT BoundingBox
 {
 public:
 	real minX;
diff --git a/src/gpu/GridGenerator/geometries/Conglomerate/Conglomerate.h b/src/gpu/GridGenerator/geometries/Conglomerate/Conglomerate.h
index 77512ba3e267d24f746883fadbdd7711d6512732..cca1a85f5110514d560481e25cc55068569a3107 100644
--- a/src/gpu/GridGenerator/geometries/Conglomerate/Conglomerate.h
+++ b/src/gpu/GridGenerator/geometries/Conglomerate/Conglomerate.h
@@ -13,7 +13,7 @@
 
 #define MAX_NUMBER_OF_OBJECTS 20
 
-class VIRTUALFLUIDS_GPU_EXPORT Conglomerate : public Object
+class GRIDGENERATOR_EXPORT Conglomerate : public Object
 {
 public:              
     HOSTDEVICE Conglomerate();
diff --git a/src/gpu/GridGenerator/geometries/Cuboid/Cuboid.h b/src/gpu/GridGenerator/geometries/Cuboid/Cuboid.h
index 5d2879ea67dcb081634675ee55464fc06dc6c970..46202f07b77f997ce25068cf55b3515c28bd9636 100644
--- a/src/gpu/GridGenerator/geometries/Cuboid/Cuboid.h
+++ b/src/gpu/GridGenerator/geometries/Cuboid/Cuboid.h
@@ -8,10 +8,11 @@
 #define CUBOID_H
 
 #include "global.h"
+#include "GridGenerator_export.h"
 
 #include "geometries/Object.h"
 
-class VIRTUALFLUIDS_GPU_EXPORT Cuboid : public Object
+class GRIDGENERATOR_EXPORT Cuboid : public Object
 {
 public:              
     HOSTDEVICE Cuboid(const double& minX1, const double& minX2, const double& minX3, const double& maxX1,const double& maxX2, const double& maxX3);
diff --git a/src/gpu/GridGenerator/geometries/Object.h b/src/gpu/GridGenerator/geometries/Object.h
index 38fd27fe6951e53a2241c0770ee0da12c16d45f0..3635a24d469f85debe099a125a1350482164af83 100644
--- a/src/gpu/GridGenerator/geometries/Object.h
+++ b/src/gpu/GridGenerator/geometries/Object.h
@@ -6,7 +6,7 @@
 //
 #ifndef OBJECT_H
 #define OBJECT_H
-
+#include "GridGenerator_export.h"
 #include <VirtualFluidsDefinitions.h>
 #include "grid/Cell.h"
 #include "global.h"
@@ -14,7 +14,7 @@
 class GridImp;
 struct Vertex;
 
-class VIRTUALFLUIDS_GPU_EXPORT Object
+class GRIDGENERATOR_EXPORT Object
 {
 public:
     HOSTDEVICE virtual ~Object() {}
diff --git a/src/gpu/GridGenerator/geometries/Sphere/Sphere.h b/src/gpu/GridGenerator/geometries/Sphere/Sphere.h
index 865da7d3b1e53efcdc7940a79185881f276d1c10..48a3cfb67a502e8537a6a5c0e2ea0f584c56583a 100644
--- a/src/gpu/GridGenerator/geometries/Sphere/Sphere.h
+++ b/src/gpu/GridGenerator/geometries/Sphere/Sphere.h
@@ -8,10 +8,10 @@
 #define SPHERE_H
 
 #include "global.h"
-
+#include "GridGenerator_export.h"
 #include "geometries/Object.h"
 
-class VIRTUALFLUIDS_GPU_EXPORT Sphere : public Object
+class GRIDGENERATOR_EXPORT Sphere : public Object
 {
 public:
     HOSTDEVICE Sphere(const double& centerX, const double& centerY, const double& centerZ, const double& radius);
diff --git a/src/gpu/GridGenerator/geometries/Triangle/Triangle.h b/src/gpu/GridGenerator/geometries/Triangle/Triangle.h
index ee16b2f17622a1f8283508af5f042f175abd428f..9c5a33895ed57ce4beaaf1c019a15766779b9942 100644
--- a/src/gpu/GridGenerator/geometries/Triangle/Triangle.h
+++ b/src/gpu/GridGenerator/geometries/Triangle/Triangle.h
@@ -4,12 +4,12 @@
 #include <memory>
 
 #include "global.h"
-
+#include "GridGenerator_export.h"
 #include "geometries/Vertex/Vertex.h"
 
 class TriangleMemento;
 
-struct VIRTUALFLUIDS_GPU_EXPORT Triangle
+struct GRIDGENERATOR_EXPORT Triangle
 {
     Vertex v1, v2, v3, normal;
     real alphaAngles[3];
diff --git a/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMesh.cu b/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMesh.cu
index 66e213eb0b7685882d85ff336325a1e663ff2605..e351b69fc4b38f983038680f93ee3f1b9fac2bc3 100644
--- a/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMesh.cu
+++ b/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMesh.cu
@@ -119,7 +119,7 @@ HOSTDEVICE GbTriFaceMesh3D* TriangularMesh::getGbTriFaceMesh3D() const
     return this->VF_GbTriFaceMesh3D.get();
 }
 
-CUDA_HOST VIRTUALFLUIDS_GPU_EXPORT void TriangularMesh::generateGbTriFaceMesh3D()
+CUDA_HOST GRIDGENERATOR_EXPORT void TriangularMesh::generateGbTriFaceMesh3D()
 {
     if( this->VF_GbTriFaceMesh3D ) return;
 
diff --git a/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMesh.h b/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMesh.h
index a67ca01cb8790dce85d1045e759b79fc46382556..fcb937f552e9d4ccb20b0c2cc15380918dc9b2e5 100644
--- a/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMesh.h
+++ b/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMesh.h
@@ -6,7 +6,7 @@
 #include <vector>
 #include <string>
 #include <memory>
-
+#include "GridGenerator_export.h"
 #include "global.h"
 
 #include "geometries/Triangle/Triangle.h"
@@ -24,16 +24,16 @@ class TriangularMesh : public Object
 {
 public:
 
-    VIRTUALFLUIDS_GPU_EXPORT static TriangularMesh* make(const std::string& fileName, const std::vector<uint> ignorePatches = std::vector<uint>());
-	VIRTUALFLUIDS_GPU_EXPORT TriangularMesh();
-    VIRTUALFLUIDS_GPU_EXPORT TriangularMesh(const std::string& inputPath, const std::vector<uint> ignorePatches = std::vector<uint>());
-	VIRTUALFLUIDS_GPU_EXPORT TriangularMesh(const std::string& inputPath, const BoundingBox &box);
-	HOSTDEVICE VIRTUALFLUIDS_GPU_EXPORT ~TriangularMesh();
+    GRIDGENERATOR_EXPORT static TriangularMesh* make(const std::string& fileName, const std::vector<uint> ignorePatches = std::vector<uint>());
+	GRIDGENERATOR_EXPORT TriangularMesh();
+    GRIDGENERATOR_EXPORT TriangularMesh(const std::string& inputPath, const std::vector<uint> ignorePatches = std::vector<uint>());
+	GRIDGENERATOR_EXPORT TriangularMesh(const std::string& inputPath, const BoundingBox &box);
+	HOSTDEVICE GRIDGENERATOR_EXPORT ~TriangularMesh();
 
-    VIRTUALFLUIDS_GPU_EXPORT uint getNumberOfTriangles() const;
+    GRIDGENERATOR_EXPORT uint getNumberOfTriangles() const;
 
-	VIRTUALFLUIDS_GPU_EXPORT void setTriangles(std::vector<Triangle> triangles);
-	VIRTUALFLUIDS_GPU_EXPORT void setMinMax(BoundingBox minmax);
+	GRIDGENERATOR_EXPORT void setTriangles(std::vector<Triangle> triangles);
+	GRIDGENERATOR_EXPORT void setMinMax(BoundingBox minmax);
 
 	std::vector<Triangle> triangleVec;
 	Triangle *triangles;
@@ -42,13 +42,13 @@ public:
 
     SPtr<GbTriFaceMesh3D> VF_GbTriFaceMesh3D;
 
-    CUDA_HOST VIRTUALFLUIDS_GPU_EXPORT bool operator==(const TriangularMesh &geometry) const;
+    CUDA_HOST GRIDGENERATOR_EXPORT bool operator==(const TriangularMesh &geometry) const;
 
-    VIRTUALFLUIDS_GPU_EXPORT void findNeighbors();
+    GRIDGENERATOR_EXPORT void findNeighbors();
 
-    HOSTDEVICE VIRTUALFLUIDS_GPU_EXPORT GbTriFaceMesh3D* getGbTriFaceMesh3D() const;
+    HOSTDEVICE GRIDGENERATOR_EXPORT GbTriFaceMesh3D* getGbTriFaceMesh3D() const;
 
-    CUDA_HOST VIRTUALFLUIDS_GPU_EXPORT void generateGbTriFaceMesh3D();
+    CUDA_HOST GRIDGENERATOR_EXPORT void generateGbTriFaceMesh3D();
 
 private:
 	
diff --git a/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMeshStrategy.h b/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMeshStrategy.h
index db6ba97e06b5696cdfd05caed07a376d0f54e75b..98d852962310fb135a19fc57067d417b86994a2c 100644
--- a/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMeshStrategy.h
+++ b/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMeshStrategy.h
@@ -2,12 +2,13 @@
 #define TriangularMeshStrategy_H
 
 #include "global.h"
+#include "GridGenerator_export.h"
 
 class GridImp;
 class TriangularMesh;
 struct Triangle;
 
-class VIRTUALFLUIDS_GPU_EXPORT TriangularMeshDiscretizationStrategy
+class GRIDGENERATOR_EXPORT TriangularMeshDiscretizationStrategy
 {
 public:
     TriangularMeshDiscretizationStrategy() {}
@@ -26,7 +27,7 @@ private:
 
 
 
-class VIRTUALFLUIDS_GPU_EXPORT PointInObjectDiscretizationStrategy : public TriangularMeshDiscretizationStrategy
+class GRIDGENERATOR_EXPORT PointInObjectDiscretizationStrategy : public TriangularMeshDiscretizationStrategy
 {
 public:
     PointInObjectDiscretizationStrategy() {}
@@ -35,7 +36,7 @@ public:
     virtual void doDiscretize(TriangularMesh* triangularMesh, GridImp* grid, char InnerType, char OuterType);
 };
 
-class VIRTUALFLUIDS_GPU_EXPORT RayCastingDiscretizationStrategy : public TriangularMeshDiscretizationStrategy
+class GRIDGENERATOR_EXPORT RayCastingDiscretizationStrategy : public TriangularMeshDiscretizationStrategy
 {
 public:
     RayCastingDiscretizationStrategy() {}
@@ -44,7 +45,7 @@ public:
     virtual void doDiscretize(TriangularMesh* triangularMesh, GridImp* grid, char InnerType, char OuterType);
 };
 
-class VIRTUALFLUIDS_GPU_EXPORT PointUnderTriangleStrategy : public TriangularMeshDiscretizationStrategy
+class GRIDGENERATOR_EXPORT PointUnderTriangleStrategy : public TriangularMeshDiscretizationStrategy
 {
 public:
     PointUnderTriangleStrategy() {}
diff --git a/src/gpu/GridGenerator/geometries/TriangularMesh/triangleNeighborFinder/TriangleNeighborFinder.h b/src/gpu/GridGenerator/geometries/TriangularMesh/triangleNeighborFinder/TriangleNeighborFinder.h
index f583062924069c097ba051a2ab1a2d642a3ce66b..be0ebc5d004bd8bff9b96d48d68064d134238afb 100644
--- a/src/gpu/GridGenerator/geometries/TriangularMesh/triangleNeighborFinder/TriangleNeighborFinder.h
+++ b/src/gpu/GridGenerator/geometries/TriangularMesh/triangleNeighborFinder/TriangleNeighborFinder.h
@@ -2,7 +2,7 @@
 #define TriangleNeighborFinder_h
 
 #include "GridGenerator/global.h"
-
+#include "GridGenerator_export.h"
 #include <vector>
 
 struct IDS {
@@ -22,14 +22,14 @@ struct IntegerPtr2D {
 class TriangleNeighborFinder
 {
 public:
-    VIRTUALFLUIDS_GPU_EXPORT TriangleNeighborFinder(Triangle *triangles, int size);
-    VIRTUALFLUIDS_GPU_EXPORT ~TriangleNeighborFinder();
+    GRIDGENERATOR_EXPORT TriangleNeighborFinder(Triangle *triangles, int size);
+    GRIDGENERATOR_EXPORT ~TriangleNeighborFinder();
     
     std::vector<int> getTriangleIDsWithCommonVertex(int vertexID) const;
     std::vector< std::vector<Triangle> > getTrianglesPerVertex() const;
 
-    void VIRTUALFLUIDS_GPU_EXPORT fillWithNeighborIndices(IntegerPtr2D *indices, Triangle *triangles);
-	void VIRTUALFLUIDS_GPU_EXPORT fillWithNeighborAngles(TriangularMesh *geom) const;
+    void GRIDGENERATOR_EXPORT fillWithNeighborIndices(IntegerPtr2D *indices, Triangle *triangles);
+	void GRIDGENERATOR_EXPORT fillWithNeighborAngles(TriangularMesh *geom) const;
 
     void printSortedToTriangles() const;
     void printSortedInSpace() const;
diff --git a/src/gpu/GridGenerator/geometries/TriangularMesh/triangleRefinement/TriangleRefinement.h b/src/gpu/GridGenerator/geometries/TriangularMesh/triangleRefinement/TriangleRefinement.h
index 911e2a91d0a1cf17e521d19fbb59c5e29f677cee..2cd5045a12ef5267f0d1971f799a55cd081badbd 100644
--- a/src/gpu/GridGenerator/geometries/TriangularMesh/triangleRefinement/TriangleRefinement.h
+++ b/src/gpu/GridGenerator/geometries/TriangularMesh/triangleRefinement/TriangleRefinement.h
@@ -14,17 +14,17 @@ struct IntegerPtr2D;
 class  TriangleRefinement
 {
 public:
-    VIRTUALFLUIDS_GPU_EXPORT TriangleRefinement(std::vector<Triangle> *triangles);
-    VIRTUALFLUIDS_GPU_EXPORT ~TriangleRefinement();
+    GRIDGENERATOR_EXPORT TriangleRefinement(std::vector<Triangle> *triangles);
+    GRIDGENERATOR_EXPORT ~TriangleRefinement();
 
-    void VIRTUALFLUIDS_GPU_EXPORT refine(int iTriangle);
-    static void VIRTUALFLUIDS_GPU_EXPORT refine(Triangle t, Triangle &firstNewTriangle, Triangle &secondNewTriangle);
+    void GRIDGENERATOR_EXPORT refine(int iTriangle);
+    static void GRIDGENERATOR_EXPORT refine(Triangle t, Triangle &firstNewTriangle, Triangle &secondNewTriangle);
     
-    void VIRTUALFLUIDS_GPU_EXPORT refineUntilMinDistance(double d_min);
-    void VIRTUALFLUIDS_GPU_EXPORT refineUntilcountTriangle(int countTri);
-    void VIRTUALFLUIDS_GPU_EXPORT redoubleTriangles();
+    void GRIDGENERATOR_EXPORT refineUntilMinDistance(double d_min);
+    void GRIDGENERATOR_EXPORT refineUntilcountTriangle(int countTri);
+    void GRIDGENERATOR_EXPORT redoubleTriangles();
 
-    static VIRTUALFLUIDS_GPU_EXPORT Vertex getHalfVertex(const Vertex &v, const Vertex &w);
+    static GRIDGENERATOR_EXPORT Vertex getHalfVertex(const Vertex &v, const Vertex &w);
 
 private:
     std::vector<Triangle> *triangles;
@@ -39,8 +39,8 @@ private:
     int findCommonEdgeFromTriangles(int indexNeighbor, int iTriangle);
 
 public:
-    static int VIRTUALFLUIDS_GPU_EXPORT getEdgeWithLongestDistance(Triangle &t);
-    static real VIRTUALFLUIDS_GPU_EXPORT getLongestEdgeDistance(Triangle &t);
+    static int GRIDGENERATOR_EXPORT getEdgeWithLongestDistance(Triangle &t);
+    static real GRIDGENERATOR_EXPORT getLongestEdgeDistance(Triangle &t);
 };
 
 
diff --git a/src/gpu/GridGenerator/geometries/Vertex/Vertex.h b/src/gpu/GridGenerator/geometries/Vertex/Vertex.h
index 23b47311afad9208b6909809847869922aeffdc2..65710b870e5e1f20cf088992fb6f35448722f3f9 100644
--- a/src/gpu/GridGenerator/geometries/Vertex/Vertex.h
+++ b/src/gpu/GridGenerator/geometries/Vertex/Vertex.h
@@ -10,7 +10,7 @@
 
 class VertexMemento;
 
-struct VIRTUALFLUIDS_GPU_EXPORT Vertex
+struct GRIDGENERATOR_EXPORT Vertex
 {
 public:
     real x, y, z;
diff --git a/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.h b/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.h
index 6d004909e1fe6804ca95e545c55e8f67bcc914ef..e1ee6fc3dbfe3f4594e344c0cb54136bca8149a1 100644
--- a/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.h
+++ b/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.h
@@ -8,10 +8,10 @@
 #define VERTICAL_CYLINDER_H
 
 #include "global.h"
-
+#include "GridGenerator_export.h"
 #include "geometries/Object.h"
 
-class VIRTUALFLUIDS_GPU_EXPORT VerticalCylinder : public Object
+class GRIDGENERATOR_EXPORT VerticalCylinder : public Object
 {
 public:
     HOSTDEVICE VerticalCylinder(const double& centerX, const double& centerY, const double& centerZ, const double& radius, const double& height);
diff --git a/src/gpu/GridGenerator/global.h b/src/gpu/GridGenerator/global.h
index b6c93da2cb1b8a4e0e5c4060401e37d25df635de..87e198b69932fde220133064a6be8612b56193c6 100644
--- a/src/gpu/GridGenerator/global.h
+++ b/src/gpu/GridGenerator/global.h
@@ -8,6 +8,7 @@
 #define MASTERRANK 0
 
 #include "VirtualFluidsDefinitions.h"
+#include "GridGenerator_export.h"
 
 #include "Core/PointerDefinitions.h"
 #include "Core/DataTypes.h"
diff --git a/src/gpu/GridGenerator/grid/BoundaryConditions/BoundaryCondition.cpp b/src/gpu/GridGenerator/grid/BoundaryConditions/BoundaryCondition.cpp
index 6ddc6b0e112a7d104ef131f8171405d236acac6e..fb60958c61e6fa53a546a8b5783e313712897123 100644
--- a/src/gpu/GridGenerator/grid/BoundaryConditions/BoundaryCondition.cpp
+++ b/src/gpu/GridGenerator/grid/BoundaryConditions/BoundaryCondition.cpp
@@ -1,7 +1,7 @@
 #include "BoundaryCondition.h"
 
 #include <cmath>
-
+#include "GridGenerator_export.h"
 #include "grid/BoundaryConditions/Side.h"
 #include "grid/Grid.h"
 
@@ -10,7 +10,7 @@ bool BoundaryCondition::isSide( SideType side ) const
     return this->side->whoAmI() == side;
 }
 
-VIRTUALFLUIDS_GPU_EXPORT void VelocityBoundaryCondition::setVelocityProfile(SPtr<Grid> grid, std::function<void(real, real, real, real&, real&, real&)> velocityProfile)
+GRIDGENERATOR_EXPORT void VelocityBoundaryCondition::setVelocityProfile(SPtr<Grid> grid, std::function<void(real, real, real, real&, real&, real&)> velocityProfile)
 {
     for( uint index = 0; index < this->indices.size(); index++ ){
 
diff --git a/src/gpu/GridGenerator/grid/BoundaryConditions/BoundaryCondition.h b/src/gpu/GridGenerator/grid/BoundaryConditions/BoundaryCondition.h
index 9765a24d2ef5cead8fea271427fe44e319ac8c22..3b58b14bf714fa184f2c6b2d9e5a78f8386c302e 100644
--- a/src/gpu/GridGenerator/grid/BoundaryConditions/BoundaryCondition.h
+++ b/src/gpu/GridGenerator/grid/BoundaryConditions/BoundaryCondition.h
@@ -96,7 +96,7 @@ public:
     real getVy(uint index) { return this->vyList[index]; }
     real getVz(uint index) { return this->vzList[index]; }
     
-    VIRTUALFLUIDS_GPU_EXPORT void setVelocityProfile( SPtr<Grid> grid, std::function<void(real,real,real,real&,real&,real&)> velocityProfile );
+    GRIDGENERATOR_EXPORT void setVelocityProfile( SPtr<Grid> grid, std::function<void(real,real,real,real&,real&,real&)> velocityProfile );
 };
 
 //////////////////////////////////////////////////////////////////////////
@@ -129,7 +129,7 @@ public:
         }
     }
 
-    VIRTUALFLUIDS_GPU_EXPORT void setTangentialVelocityForPatch( SPtr<Grid> grid, uint patch,
+    GRIDGENERATOR_EXPORT void setTangentialVelocityForPatch( SPtr<Grid> grid, uint patch,
                                                   real p1x, real p1y, real p1z, 
                                                   real p2x, real p2y, real p2z, 
                                                   real v, real r );
diff --git a/src/gpu/GridGenerator/grid/Field.h b/src/gpu/GridGenerator/grid/Field.h
index 620e6780fd95e961115e9aec867c30252198e924..f79797afab158f0f80d515f2aa38ed8b91438dc2 100644
--- a/src/gpu/GridGenerator/grid/Field.h
+++ b/src/gpu/GridGenerator/grid/Field.h
@@ -6,7 +6,7 @@
 struct Vertex;
 class GridStrategy;
 
-class VIRTUALFLUIDS_GPU_EXPORT Field : public enableSharedFromThis<Field>
+class GRIDGENERATOR_EXPORT Field : public enableSharedFromThis<Field>
 {
 public:
     CUDA_HOST Field(SPtr<GridStrategy> gridStrategy, uint size);
diff --git a/src/gpu/GridGenerator/grid/Grid.h b/src/gpu/GridGenerator/grid/Grid.h
index 21fdeaa656db553db8feecc681aa3c07250a6e72..e4bbfdecb3decf414efb42d5b13f2faa710bde69 100644
--- a/src/gpu/GridGenerator/grid/Grid.h
+++ b/src/gpu/GridGenerator/grid/Grid.h
@@ -17,7 +17,7 @@ class GridInterface;
 class Object;
 class BoundingBox;
 
-class VIRTUALFLUIDS_GPU_EXPORT Grid
+class GRIDGENERATOR_EXPORT Grid
 {
 public:
     HOSTDEVICE virtual ~Grid() {}
diff --git a/src/gpu/GridGenerator/grid/GridBuilder/GridBuilder.h b/src/gpu/GridGenerator/grid/GridBuilder/GridBuilder.h
index 7550cb582a7a532c0140d8f6529b72da258a425c..8136bd38d97820955be5b1210293b6abcd4b64ff 100644
--- a/src/gpu/GridGenerator/grid/GridBuilder/GridBuilder.h
+++ b/src/gpu/GridGenerator/grid/GridBuilder/GridBuilder.h
@@ -39,9 +39,9 @@ public:
         CPU, GPU
     };
 
-    virtual VIRTUALFLUIDS_GPU_EXPORT ~GridBuilder() {}
+    virtual GRIDGENERATOR_EXPORT ~GridBuilder() {}
     virtual void getGridInformations(std::vector<int>& gridX, std::vector<int>& gridY, std::vector<int>& gridZ, std::vector<int>& distX, std::vector<int>& distY, std::vector<int>& distZ) = 0;
-    virtual VIRTUALFLUIDS_GPU_EXPORT uint getNumberOfGridLevels() const = 0;
+    virtual GRIDGENERATOR_EXPORT uint getNumberOfGridLevels() const = 0;
 
 
     virtual void writeArrows(std::string fileName) const = 0;
diff --git a/src/gpu/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp b/src/gpu/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp
index dfb06790d8b20e930c0b35ed52d843c3694b3d41..8d2025d4f305e268b645dd651a5d736a0d3b1c47 100644
--- a/src/gpu/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp
+++ b/src/gpu/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp
@@ -126,18 +126,18 @@ void LevelGridBuilder::setNoSlipBoundaryCondition(SideType sideType)
     }
 }
 
-VIRTUALFLUIDS_GPU_EXPORT void LevelGridBuilder::setEnableFixRefinementIntoTheWall(bool enableFixRefinementIntoTheWall)
+GRIDGENERATOR_EXPORT void LevelGridBuilder::setEnableFixRefinementIntoTheWall(bool enableFixRefinementIntoTheWall)
 {
     for( uint level = 0; level < this->grids.size(); level++ )
         grids[level]->setEnableFixRefinementIntoTheWall( enableFixRefinementIntoTheWall );
 }
 
-VIRTUALFLUIDS_GPU_EXPORT void LevelGridBuilder::setCommunicationProcess(int direction, uint process)
+GRIDGENERATOR_EXPORT void LevelGridBuilder::setCommunicationProcess(int direction, uint process)
 {
     this->communicationProcesses[direction] = process;
 }
 
-VIRTUALFLUIDS_GPU_EXPORT uint LevelGridBuilder::getCommunicationProcess(int direction)
+GRIDGENERATOR_EXPORT uint LevelGridBuilder::getCommunicationProcess(int direction)
 {
     return this->communicationProcesses[direction];
 }
@@ -228,17 +228,17 @@ void LevelGridBuilder::getOffsetCF(real * xOffCF, real * yOffCF, real * zOffCF,
     }
 }
 
-VIRTUALFLUIDS_GPU_EXPORT uint LevelGridBuilder::getNumberOfSendIndices(int direction, uint level)
+GRIDGENERATOR_EXPORT uint LevelGridBuilder::getNumberOfSendIndices(int direction, uint level)
 {
     return this->grids[level]->getNumberOfSendNodes(direction);
 }
 
-VIRTUALFLUIDS_GPU_EXPORT uint LevelGridBuilder::getNumberOfReceiveIndices(int direction, uint level)
+GRIDGENERATOR_EXPORT uint LevelGridBuilder::getNumberOfReceiveIndices(int direction, uint level)
 {
     return this->grids[level]->getNumberOfReceiveNodes(direction);
 }
 
-VIRTUALFLUIDS_GPU_EXPORT void LevelGridBuilder::getSendIndices(int * sendIndices, int direction, int level)
+GRIDGENERATOR_EXPORT void LevelGridBuilder::getSendIndices(int * sendIndices, int direction, int level)
 {
     SPtr<Grid> grid = this->grids[level];
     for( uint i = 0; i < getNumberOfSendIndices(direction, level); i++ )
@@ -247,7 +247,7 @@ VIRTUALFLUIDS_GPU_EXPORT void LevelGridBuilder::getSendIndices(int * sendIndices
     }
 }
 
-VIRTUALFLUIDS_GPU_EXPORT void LevelGridBuilder::getReceiveIndices(int * receiveIndices, int direction, int level)
+GRIDGENERATOR_EXPORT void LevelGridBuilder::getReceiveIndices(int * receiveIndices, int direction, int level)
 {
     SPtr<Grid> grid = this->grids[level];
     for( uint i = 0; i < getNumberOfReceiveIndices(direction, level); i++ )
@@ -469,7 +469,7 @@ void LevelGridBuilder::writeArrows(std::string fileName) const
     QLineWriter::writeArrows(fileName, boundaryConditions[getNumberOfGridLevels() - 1]->geometryBoundaryCondition, grids[getNumberOfGridLevels() - 1]);
 }
 
-VIRTUALFLUIDS_GPU_EXPORT SPtr<BoundaryCondition> LevelGridBuilder::getBoundaryCondition(SideType side, uint level) const
+GRIDGENERATOR_EXPORT SPtr<BoundaryCondition> LevelGridBuilder::getBoundaryCondition(SideType side, uint level) const
 {
     for( auto bc : this->boundaryConditions[level]->pressureBoundaryConditions )
         if( bc->isSide(side) )
@@ -487,7 +487,7 @@ VIRTUALFLUIDS_GPU_EXPORT SPtr<BoundaryCondition> LevelGridBuilder::getBoundaryCo
     return nullptr;
 }
 
-VIRTUALFLUIDS_GPU_EXPORT SPtr<GeometryBoundaryCondition> LevelGridBuilder::getGeometryBoundaryCondition(uint level) const
+GRIDGENERATOR_EXPORT SPtr<GeometryBoundaryCondition> LevelGridBuilder::getGeometryBoundaryCondition(uint level) const
 {
     return this->boundaryConditions[level]->geometryBoundaryCondition;
 }
diff --git a/src/gpu/GridGenerator/grid/GridBuilder/LevelGridBuilder.h b/src/gpu/GridGenerator/grid/GridBuilder/LevelGridBuilder.h
index 51a8830a69976e20e9ca7acfd7b174b26f5c333e..252debf9b55b83a643b6eed5898ee6d8243d1d53 100644
--- a/src/gpu/GridGenerator/grid/GridBuilder/LevelGridBuilder.h
+++ b/src/gpu/GridGenerator/grid/GridBuilder/LevelGridBuilder.h
@@ -32,57 +32,57 @@ enum class SideType;
 class LevelGridBuilder : public GridBuilder
 {
 protected:
-    VIRTUALFLUIDS_GPU_EXPORT LevelGridBuilder(Device device, const std::string& d3qxx);
+    GRIDGENERATOR_EXPORT LevelGridBuilder(Device device, const std::string& d3qxx);
 
 public:
-    VIRTUALFLUIDS_GPU_EXPORT static std::shared_ptr<LevelGridBuilder> makeShared(Device device, const std::string& d3qxx);
+    GRIDGENERATOR_EXPORT static std::shared_ptr<LevelGridBuilder> makeShared(Device device, const std::string& d3qxx);
 
-    VIRTUALFLUIDS_GPU_EXPORT SPtr<Grid> getGrid(uint level) override;
+    GRIDGENERATOR_EXPORT SPtr<Grid> getGrid(uint level) override;
 
-    VIRTUALFLUIDS_GPU_EXPORT void copyDataFromGpu();
-    VIRTUALFLUIDS_GPU_EXPORT virtual ~LevelGridBuilder();
+    GRIDGENERATOR_EXPORT void copyDataFromGpu();
+    GRIDGENERATOR_EXPORT virtual ~LevelGridBuilder();
 
-    VIRTUALFLUIDS_GPU_EXPORT void setVelocityBoundaryCondition(SideType sideType, real vx, real vy, real vz);
-    VIRTUALFLUIDS_GPU_EXPORT void setPressureBoundaryCondition(SideType sideType, real rho);
-    VIRTUALFLUIDS_GPU_EXPORT void setPeriodicBoundaryCondition(bool periodic_X, bool periodic_Y, bool periodic_Z);
-    VIRTUALFLUIDS_GPU_EXPORT void setNoSlipBoundaryCondition(SideType sideType);
+    GRIDGENERATOR_EXPORT void setVelocityBoundaryCondition(SideType sideType, real vx, real vy, real vz);
+    GRIDGENERATOR_EXPORT void setPressureBoundaryCondition(SideType sideType, real rho);
+    GRIDGENERATOR_EXPORT void setPeriodicBoundaryCondition(bool periodic_X, bool periodic_Y, bool periodic_Z);
+    GRIDGENERATOR_EXPORT void setNoSlipBoundaryCondition(SideType sideType);
 
-    VIRTUALFLUIDS_GPU_EXPORT void setEnableFixRefinementIntoTheWall( bool enableFixRefinementIntoTheWall );
+    GRIDGENERATOR_EXPORT void setEnableFixRefinementIntoTheWall( bool enableFixRefinementIntoTheWall );
 
-    VIRTUALFLUIDS_GPU_EXPORT void setCommunicationProcess(int direction, uint process);
+    GRIDGENERATOR_EXPORT void setCommunicationProcess(int direction, uint process);
 
-    VIRTUALFLUIDS_GPU_EXPORT uint getCommunicationProcess(int direction) override;
+    GRIDGENERATOR_EXPORT uint getCommunicationProcess(int direction) override;
 
-    VIRTUALFLUIDS_GPU_EXPORT virtual std::shared_ptr<Grid> getGrid(int level, int box);
+    GRIDGENERATOR_EXPORT virtual std::shared_ptr<Grid> getGrid(int level, int box);
 
 
-    VIRTUALFLUIDS_GPU_EXPORT virtual unsigned int getNumberOfNodes(unsigned int level) const;
+    GRIDGENERATOR_EXPORT virtual unsigned int getNumberOfNodes(unsigned int level) const;
 
 
-    VIRTUALFLUIDS_GPU_EXPORT virtual void getNodeValues(real *xCoords, real *yCoords, real *zCoords,
+    GRIDGENERATOR_EXPORT virtual void getNodeValues(real *xCoords, real *yCoords, real *zCoords,
                                          uint *neighborX, uint *neighborY, uint *neighborZ, uint *neighborNegative, 
                                          uint *geo, const int level) const override;
-    VIRTUALFLUIDS_GPU_EXPORT virtual void getDimensions(int &nx, int &ny, int &nz, const int level) const;
+    GRIDGENERATOR_EXPORT virtual void getDimensions(int &nx, int &ny, int &nz, const int level) const;
 
 
-    VIRTUALFLUIDS_GPU_EXPORT uint getVelocitySize(int level) const;
-    VIRTUALFLUIDS_GPU_EXPORT virtual void getVelocityValues(real* vx, real* vy, real* vz, int* indices, int level) const;
-    VIRTUALFLUIDS_GPU_EXPORT virtual void getVelocityQs(real* qs[27], int level) const;
-    VIRTUALFLUIDS_GPU_EXPORT uint getPressureSize(int level) const override;
-    VIRTUALFLUIDS_GPU_EXPORT void getPressureValues(real* rho, int* indices, int* neighborIndices, int level) const override;
-    VIRTUALFLUIDS_GPU_EXPORT virtual void getPressureQs(real* qs[27], int level) const;
+    GRIDGENERATOR_EXPORT uint getVelocitySize(int level) const;
+    GRIDGENERATOR_EXPORT virtual void getVelocityValues(real* vx, real* vy, real* vz, int* indices, int level) const;
+    GRIDGENERATOR_EXPORT virtual void getVelocityQs(real* qs[27], int level) const;
+    GRIDGENERATOR_EXPORT uint getPressureSize(int level) const override;
+    GRIDGENERATOR_EXPORT void getPressureValues(real* rho, int* indices, int* neighborIndices, int level) const override;
+    GRIDGENERATOR_EXPORT virtual void getPressureQs(real* qs[27], int level) const;
 
-    VIRTUALFLUIDS_GPU_EXPORT virtual void getGeometryQs(real* qs[27], int level) const;
-    VIRTUALFLUIDS_GPU_EXPORT virtual uint getGeometrySize(int level) const;
-    VIRTUALFLUIDS_GPU_EXPORT virtual void getGeometryIndices(int* indices, int level) const;
-    VIRTUALFLUIDS_GPU_EXPORT virtual bool hasGeometryValues() const;
-    VIRTUALFLUIDS_GPU_EXPORT virtual void getGeometryValues(real* vx, real* vy, real* vz, int level) const;
+    GRIDGENERATOR_EXPORT virtual void getGeometryQs(real* qs[27], int level) const;
+    GRIDGENERATOR_EXPORT virtual uint getGeometrySize(int level) const;
+    GRIDGENERATOR_EXPORT virtual void getGeometryIndices(int* indices, int level) const;
+    GRIDGENERATOR_EXPORT virtual bool hasGeometryValues() const;
+    GRIDGENERATOR_EXPORT virtual void getGeometryValues(real* vx, real* vy, real* vz, int level) const;
 
 
-    VIRTUALFLUIDS_GPU_EXPORT void writeArrows(std::string fileName) const;
+    GRIDGENERATOR_EXPORT void writeArrows(std::string fileName) const;
 
-    VIRTUALFLUIDS_GPU_EXPORT SPtr<BoundaryCondition> getBoundaryCondition( SideType side, uint level ) const override;
-    VIRTUALFLUIDS_GPU_EXPORT SPtr<GeometryBoundaryCondition> getGeometryBoundaryCondition(uint level) const override;
+    GRIDGENERATOR_EXPORT SPtr<BoundaryCondition> getBoundaryCondition( SideType side, uint level ) const override;
+    GRIDGENERATOR_EXPORT SPtr<GeometryBoundaryCondition> getGeometryBoundaryCondition(uint level) const override;
 
 protected:
     
@@ -126,23 +126,23 @@ private:
     std::string d3qxx;
 
 public:
-    VIRTUALFLUIDS_GPU_EXPORT void getGridInformations(std::vector<int>& gridX, std::vector<int>& gridY,
+    GRIDGENERATOR_EXPORT void getGridInformations(std::vector<int>& gridX, std::vector<int>& gridY,
                                        std::vector<int>& gridZ, std::vector<int>& distX, std::vector<int>& distY,
                                        std::vector<int>& distZ) override;
-    VIRTUALFLUIDS_GPU_EXPORT uint getNumberOfGridLevels() const override;
+    GRIDGENERATOR_EXPORT uint getNumberOfGridLevels() const override;
 
-    VIRTUALFLUIDS_GPU_EXPORT uint getNumberOfNodesCF(int level) override;
-    VIRTUALFLUIDS_GPU_EXPORT uint getNumberOfNodesFC(int level) override;
+    GRIDGENERATOR_EXPORT uint getNumberOfNodesCF(int level) override;
+    GRIDGENERATOR_EXPORT uint getNumberOfNodesFC(int level) override;
 
-    VIRTUALFLUIDS_GPU_EXPORT void getGridInterfaceIndices(uint* iCellCfc, uint* iCellCff, uint* iCellFcc, uint* iCellFcf, int level) const override;
+    GRIDGENERATOR_EXPORT void getGridInterfaceIndices(uint* iCellCfc, uint* iCellCff, uint* iCellFcc, uint* iCellFcf, int level) const override;
 
-    VIRTUALFLUIDS_GPU_EXPORT void getOffsetFC(real* xOffCf, real* yOffCf, real* zOffCf, int level) override;
-    VIRTUALFLUIDS_GPU_EXPORT void getOffsetCF(real* xOffFc, real* yOffFc, real* zOffFc, int level) override;
+    GRIDGENERATOR_EXPORT void getOffsetFC(real* xOffCf, real* yOffCf, real* zOffCf, int level) override;
+    GRIDGENERATOR_EXPORT void getOffsetCF(real* xOffFc, real* yOffFc, real* zOffFc, int level) override;
 
-    VIRTUALFLUIDS_GPU_EXPORT uint getNumberOfSendIndices( int direction, uint level ) override;
-    VIRTUALFLUIDS_GPU_EXPORT uint getNumberOfReceiveIndices( int direction, uint level ) override;
-    VIRTUALFLUIDS_GPU_EXPORT void getSendIndices( int* sendIndices, int direction, int level ) override;
-    VIRTUALFLUIDS_GPU_EXPORT void getReceiveIndices( int* sendIndices, int direction, int level ) override;
+    GRIDGENERATOR_EXPORT uint getNumberOfSendIndices( int direction, uint level ) override;
+    GRIDGENERATOR_EXPORT uint getNumberOfReceiveIndices( int direction, uint level ) override;
+    GRIDGENERATOR_EXPORT void getSendIndices( int* sendIndices, int direction, int level ) override;
+    GRIDGENERATOR_EXPORT void getReceiveIndices( int* sendIndices, int direction, int level ) override;
 
 };
 
diff --git a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
index 1dda75c8c486c0e58b7e3c6774c783552466c1ec..1fa4d3ccb08dc5e0d3d31f68e4c3e28d6af798e5 100644
--- a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
+++ b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
@@ -571,7 +571,7 @@ void MultipleGridBuilder::buildGrids( LbmOrGks lbmOrGks, bool enableThinWalls )
     //////////////////////////////////////////////////////////////////////////
 }
 
-VIRTUALFLUIDS_GPU_EXPORT void MultipleGridBuilder::setNumberOfLayers(uint numberOfLayersFine, uint numberOfLayersBetweenLevels)
+GRIDGENERATOR_EXPORT void MultipleGridBuilder::setNumberOfLayers(uint numberOfLayersFine, uint numberOfLayersBetweenLevels)
 {
     this->numberOfLayersFine = numberOfLayersFine;
     this->numberOfLayersBetweenLevels = numberOfLayersBetweenLevels;
@@ -618,7 +618,7 @@ void MultipleGridBuilder::writeGridsToVtk(const std::string& path) const
     }
 }
 
-VIRTUALFLUIDS_GPU_EXPORT void MultipleGridBuilder::setSubDomainBox(SPtr<BoundingBox> subDomainBox)
+GRIDGENERATOR_EXPORT void MultipleGridBuilder::setSubDomainBox(SPtr<BoundingBox> subDomainBox)
 {
     this->subDomainBox = subDomainBox;
 }
diff --git a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h
index a22c87799400441ead7a7ebeceeca70d5950ccdf..8fa61f8484c77d539331697e22b383176cdd19f4 100644
--- a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h
+++ b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h
@@ -3,7 +3,7 @@
 
 #include <vector>
 #include <array>
-
+#include "GridGenerator_export.h"
 #include "Core/LbmOrGks.h"
 
 #include "global.h"
@@ -17,37 +17,37 @@ class BoundingBox;
 class MultipleGridBuilder : public LevelGridBuilder
 {
 private:
-    VIRTUALFLUIDS_GPU_EXPORT MultipleGridBuilder(SPtr<GridFactory> gridFactory, Device device = Device::CPU, const std::string &d3qxx = "D3Q27");
+    GRIDGENERATOR_EXPORT MultipleGridBuilder(SPtr<GridFactory> gridFactory, Device device = Device::CPU, const std::string &d3qxx = "D3Q27");
 
 public:
-    VIRTUALFLUIDS_GPU_EXPORT static SPtr<MultipleGridBuilder> makeShared(SPtr<GridFactory> gridFactory);
+    GRIDGENERATOR_EXPORT static SPtr<MultipleGridBuilder> makeShared(SPtr<GridFactory> gridFactory);
 
-    VIRTUALFLUIDS_GPU_EXPORT void addCoarseGrid(real startX, real startY, real startZ, real endX, real endY, real endZ, real delta);
-    VIRTUALFLUIDS_GPU_EXPORT void addGrid(Object* gridShape);
-    VIRTUALFLUIDS_GPU_EXPORT void addGrid(Object* gridShape, uint levelFine);
+    GRIDGENERATOR_EXPORT void addCoarseGrid(real startX, real startY, real startZ, real endX, real endY, real endZ, real delta);
+    GRIDGENERATOR_EXPORT void addGrid(Object* gridShape);
+    GRIDGENERATOR_EXPORT void addGrid(Object* gridShape, uint levelFine);
 
-    VIRTUALFLUIDS_GPU_EXPORT void addGeometry(Object* gridShape);
-    VIRTUALFLUIDS_GPU_EXPORT void addGeometry(Object* solidObject, uint level);
+    GRIDGENERATOR_EXPORT void addGeometry(Object* gridShape);
+    GRIDGENERATOR_EXPORT void addGeometry(Object* solidObject, uint level);
 
-    VIRTUALFLUIDS_GPU_EXPORT uint getNumberOfLevels() const;
-    VIRTUALFLUIDS_GPU_EXPORT real getDelta(uint level) const;
+    GRIDGENERATOR_EXPORT uint getNumberOfLevels() const;
+    GRIDGENERATOR_EXPORT real getDelta(uint level) const;
 
-    VIRTUALFLUIDS_GPU_EXPORT real getStartX(uint level) const;
-    VIRTUALFLUIDS_GPU_EXPORT real getStartY(uint level) const;
-    VIRTUALFLUIDS_GPU_EXPORT real getStartZ(uint level) const;
+    GRIDGENERATOR_EXPORT real getStartX(uint level) const;
+    GRIDGENERATOR_EXPORT real getStartY(uint level) const;
+    GRIDGENERATOR_EXPORT real getStartZ(uint level) const;
 
-    VIRTUALFLUIDS_GPU_EXPORT real getEndX(uint level) const;
-    VIRTUALFLUIDS_GPU_EXPORT real getEndY(uint level) const;
-    VIRTUALFLUIDS_GPU_EXPORT real getEndZ(uint level) const;
+    GRIDGENERATOR_EXPORT real getEndX(uint level) const;
+    GRIDGENERATOR_EXPORT real getEndY(uint level) const;
+    GRIDGENERATOR_EXPORT real getEndZ(uint level) const;
 
-    VIRTUALFLUIDS_GPU_EXPORT std::vector<SPtr<Grid> > getGrids() const;
-    VIRTUALFLUIDS_GPU_EXPORT void buildGrids(LbmOrGks lbmOrGks, bool enableThinWalls = false);
+    GRIDGENERATOR_EXPORT std::vector<SPtr<Grid> > getGrids() const;
+    GRIDGENERATOR_EXPORT void buildGrids(LbmOrGks lbmOrGks, bool enableThinWalls = false);
 
-    VIRTUALFLUIDS_GPU_EXPORT void setNumberOfLayers( uint numberOfLayersFine, uint numberOfLayersBetweenLevels );
+    GRIDGENERATOR_EXPORT void setNumberOfLayers( uint numberOfLayersFine, uint numberOfLayersBetweenLevels );
 
-    VIRTUALFLUIDS_GPU_EXPORT void writeGridsToVtk(const std::string& path) const;
+    GRIDGENERATOR_EXPORT void writeGridsToVtk(const std::string& path) const;
 
-    VIRTUALFLUIDS_GPU_EXPORT void setSubDomainBox(SPtr<BoundingBox> subDomainBox);
+    GRIDGENERATOR_EXPORT void setSubDomainBox(SPtr<BoundingBox> subDomainBox);
 
 private:
     void addGridToList(SPtr<Grid> grid);
@@ -83,7 +83,7 @@ private:
 
 public:
 
-    VIRTUALFLUIDS_GPU_EXPORT void findCommunicationIndices( int direction, LbmOrGks lbmOrGks );
+    GRIDGENERATOR_EXPORT void findCommunicationIndices( int direction, LbmOrGks lbmOrGks );
 };
 
 #endif
diff --git a/src/gpu/GridGenerator/grid/GridFactory.h b/src/gpu/GridGenerator/grid/GridFactory.h
index 57f3e4849c32a44bcd7b47fb8dea9e1cfa398c10..b22d01ea12bbbc2cbf932d7b11eeb404dddffa58 100644
--- a/src/gpu/GridGenerator/grid/GridFactory.h
+++ b/src/gpu/GridGenerator/grid/GridFactory.h
@@ -22,7 +22,7 @@ enum class TriangularMeshDiscretizationMethod
     RAYCASTING, POINT_IN_OBJECT, POINT_UNDER_TRIANGLE
 };
 
-class VIRTUALFLUIDS_GPU_EXPORT GridFactory
+class GRIDGENERATOR_EXPORT GridFactory
 {
 public:
     static SPtr<GridFactory> make()
diff --git a/src/gpu/GridGenerator/grid/GridImp.h b/src/gpu/GridGenerator/grid/GridImp.h
index d58b1b70b8a721a5ab0dad2b99f8138607724904..be9bc9e17e4f91ddeb7dd743380039c0811a822f 100644
--- a/src/gpu/GridGenerator/grid/GridImp.h
+++ b/src/gpu/GridGenerator/grid/GridImp.h
@@ -23,7 +23,7 @@ class TriangularMeshDiscretizationStrategy;
 
 extern CONSTANT int DIRECTIONS[DIR_END_MAX][DIMENSION];
 
-class VIRTUALFLUIDS_GPU_EXPORT GridImp : public enableSharedFromThis<GridImp>, public Grid
+class GRIDGENERATOR_EXPORT GridImp : public enableSharedFromThis<GridImp>, public Grid
 {
 private:
     CUDA_HOST GridImp();
diff --git a/src/gpu/GridGenerator/grid/GridInterface.cu b/src/gpu/GridGenerator/grid/GridInterface.cu
index e05b017c83b009f79229cf4edfb6534838ff9b0b..00ce04f098f7f24332167d310f9dc30259907987 100644
--- a/src/gpu/GridGenerator/grid/GridInterface.cu
+++ b/src/gpu/GridGenerator/grid/GridInterface.cu
@@ -254,7 +254,7 @@ void GridInterface::findForGridInterfaceSparseIndexFC(GridImp* coarseGrid, GridI
     findSparseIndex(fc.fine, fineGrid, index);
 }
 
-CUDA_HOST void VIRTUALFLUIDS_GPU_EXPORT GridInterface::repairGridInterfaceOnMultiGPU(SPtr<GridImp> coarseGrid, SPtr<GridImp> fineGrid)
+CUDA_HOST void GRIDGENERATOR_EXPORT GridInterface::repairGridInterfaceOnMultiGPU(SPtr<GridImp> coarseGrid, SPtr<GridImp> fineGrid)
 {
     {
         std::vector<uint> tmpCFC;
diff --git a/src/gpu/GridGenerator/grid/GridInterface.h b/src/gpu/GridGenerator/grid/GridInterface.h
index 0fa224c31ab99a6bba293fe040e5189591f35bcf..d0f04ea3451b3044c349aa0e27d2f7c6e567128c 100644
--- a/src/gpu/GridGenerator/grid/GridInterface.h
+++ b/src/gpu/GridGenerator/grid/GridInterface.h
@@ -8,26 +8,26 @@ class GridImp;
 class GridInterface
 {
 public:
-    HOSTDEVICE VIRTUALFLUIDS_GPU_EXPORT GridInterface();
-    HOSTDEVICE VIRTUALFLUIDS_GPU_EXPORT ~GridInterface();
+    HOSTDEVICE GRIDGENERATOR_EXPORT GridInterface();
+    HOSTDEVICE GRIDGENERATOR_EXPORT ~GridInterface();
 
-    HOSTDEVICE void VIRTUALFLUIDS_GPU_EXPORT findInterfaceCF(const uint& indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid);
-    HOSTDEVICE void VIRTUALFLUIDS_GPU_EXPORT findBoundaryGridInterfaceCF(const uint& indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid);
+    HOSTDEVICE void GRIDGENERATOR_EXPORT findInterfaceCF(const uint& indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid);
+    HOSTDEVICE void GRIDGENERATOR_EXPORT findBoundaryGridInterfaceCF(const uint& indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid);
 
 
-	HOSTDEVICE void VIRTUALFLUIDS_GPU_EXPORT findInterfaceCF_GKS(const uint& indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid);
+	HOSTDEVICE void GRIDGENERATOR_EXPORT findInterfaceCF_GKS(const uint& indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid);
 
-	HOSTDEVICE void VIRTUALFLUIDS_GPU_EXPORT findInterfaceFC(const uint& indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid);
-    HOSTDEVICE void VIRTUALFLUIDS_GPU_EXPORT findOverlapStopper(const uint& indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid);
+	HOSTDEVICE void GRIDGENERATOR_EXPORT findInterfaceFC(const uint& indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid);
+    HOSTDEVICE void GRIDGENERATOR_EXPORT findOverlapStopper(const uint& indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid);
     
-    HOSTDEVICE void VIRTUALFLUIDS_GPU_EXPORT findInvalidBoundaryNodes(const uint& indexOnCoarseGrid, GridImp* coarseGrid);
+    HOSTDEVICE void GRIDGENERATOR_EXPORT findInvalidBoundaryNodes(const uint& indexOnCoarseGrid, GridImp* coarseGrid);
 
-    HOSTDEVICE void VIRTUALFLUIDS_GPU_EXPORT findForGridInterfaceSparseIndexCF(GridImp* coarseGrid, GridImp* fineGrid, uint index);
-    HOSTDEVICE void VIRTUALFLUIDS_GPU_EXPORT findForGridInterfaceSparseIndexFC(GridImp* coarseGrid, GridImp* fineGrid, uint index);
+    HOSTDEVICE void GRIDGENERATOR_EXPORT findForGridInterfaceSparseIndexCF(GridImp* coarseGrid, GridImp* fineGrid, uint index);
+    HOSTDEVICE void GRIDGENERATOR_EXPORT findForGridInterfaceSparseIndexFC(GridImp* coarseGrid, GridImp* fineGrid, uint index);
 
-    CUDA_HOST void VIRTUALFLUIDS_GPU_EXPORT repairGridInterfaceOnMultiGPU(SPtr<GridImp> coarseGrid, SPtr<GridImp> fineGrid);
+    CUDA_HOST void GRIDGENERATOR_EXPORT repairGridInterfaceOnMultiGPU(SPtr<GridImp> coarseGrid, SPtr<GridImp> fineGrid);
 
-    HOSTDEVICE void VIRTUALFLUIDS_GPU_EXPORT print() const;
+    HOSTDEVICE void GRIDGENERATOR_EXPORT print() const;
 
     struct Interface
     {
diff --git a/src/gpu/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.h b/src/gpu/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.h
index b5b91af92baeb4d9b69d9374dd418ba5a8b82482..af4b1791b0970f1f26483b46953ebc2512dd23bc 100644
--- a/src/gpu/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.h
+++ b/src/gpu/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.h
@@ -8,7 +8,7 @@
 class GridImp;
 class TriangularMesh;
 
-class VIRTUALFLUIDS_GPU_EXPORT GridCpuStrategy : public GridStrategy
+class GRIDGENERATOR_EXPORT GridCpuStrategy : public GridStrategy
 {
 public:
     virtual ~GridCpuStrategy() {};
diff --git a/src/gpu/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.h b/src/gpu/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.h
index 8ba30824a21be31740fb5d8260528e50529a4d5a..fb886824ad35e6657f49c23a3fc25e19aabf0783 100644
--- a/src/gpu/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.h
+++ b/src/gpu/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.h
@@ -8,7 +8,7 @@
 class BoundingBox;
 class TriangularMesh;
 
-class VIRTUALFLUIDS_GPU_EXPORT GridGpuStrategy : public GridStrategy
+class GRIDGENERATOR_EXPORT GridGpuStrategy : public GridStrategy
 {
 public:
     virtual ~GridGpuStrategy() {};
diff --git a/src/gpu/GridGenerator/grid/GridStrategy/GridStrategy.h b/src/gpu/GridGenerator/grid/GridStrategy/GridStrategy.h
index 44152ffedd5d7f04a2049f13ded85b94f5a6a90e..4bf735f90dab005241160266836b910e1c113cea 100644
--- a/src/gpu/GridGenerator/grid/GridStrategy/GridStrategy.h
+++ b/src/gpu/GridGenerator/grid/GridStrategy/GridStrategy.h
@@ -11,7 +11,7 @@ struct Vertex;
 class TriangularMesh;
 class GridImp;
 
-class VIRTUALFLUIDS_GPU_EXPORT GridStrategy
+class GRIDGENERATOR_EXPORT GridStrategy
 {
 public:
     virtual ~GridStrategy() {}
diff --git a/src/gpu/GridGenerator/grid/distributions/Distribution.h b/src/gpu/GridGenerator/grid/distributions/Distribution.h
index 5ba90548f1d0ad40dbc818cea02892c241c69264..b05b5db3652ee952ff083db560ed8316688819c9 100644
--- a/src/gpu/GridGenerator/grid/distributions/Distribution.h
+++ b/src/gpu/GridGenerator/grid/distributions/Distribution.h
@@ -60,7 +60,7 @@ struct Distribution
 
 class Grid;
 
-class VIRTUALFLUIDS_GPU_EXPORT DistributionHelper
+class GRIDGENERATOR_EXPORT DistributionHelper
 {
 public:
     static Distribution getDistribution7();
diff --git a/src/gpu/GridGenerator/grid/partition/Partition.h b/src/gpu/GridGenerator/grid/partition/Partition.h
index 4b9c109d53c5ce5e3bad2c2459af35e02c09703f..a45f7668b871f6910332de7262c6d407f32d1d7f 100644
--- a/src/gpu/GridGenerator/grid/partition/Partition.h
+++ b/src/gpu/GridGenerator/grid/partition/Partition.h
@@ -14,7 +14,7 @@
 //class Grid;
 //class Transformator;
 //
-//class VIRTUALFLUIDS_GPU_EXPORT Partition
+//class GRIDGENERATOR_EXPORT Partition
 //{
 //public:
 //    static void partitionGridMesh(SPtr<Grid> grid);
diff --git a/src/gpu/GridGenerator/io/GridVTKWriter/GridVTKWriter.h b/src/gpu/GridGenerator/io/GridVTKWriter/GridVTKWriter.h
index 5a4ba5466e23ca763c41a024f13bf8a963874063..43fe611459a2509ddb032cce993b171673fa407f 100644
--- a/src/gpu/GridGenerator/io/GridVTKWriter/GridVTKWriter.h
+++ b/src/gpu/GridGenerator/io/GridVTKWriter/GridVTKWriter.h
@@ -4,12 +4,13 @@
 #include <string>
 
 #include "global.h"
+#include "GridGenerator_export.h"
 
 enum class WRITING_FORMAT { BINARY, ASCII };
 
 class Grid;
 
-class VIRTUALFLUIDS_GPU_EXPORT GridVTKWriter
+class GRIDGENERATOR_EXPORT GridVTKWriter
 {
 public:
     static void writeSparseGridToVTK(SPtr<Grid> grid, const std::string& name, WRITING_FORMAT format = WRITING_FORMAT::ASCII);
diff --git a/src/gpu/GridGenerator/io/STLReaderWriter/STLReader.h b/src/gpu/GridGenerator/io/STLReaderWriter/STLReader.h
index d0fa2d3f97dd1e1f4b9364352656226c94e6443f..3e7beef8c6b0d81c454d2ca6fec5fca5d0d7f6d4 100644
--- a/src/gpu/GridGenerator/io/STLReaderWriter/STLReader.h
+++ b/src/gpu/GridGenerator/io/STLReaderWriter/STLReader.h
@@ -11,7 +11,7 @@ struct Triangle;
 struct Vertex;
 class BoundingBox;
 
-class VIRTUALFLUIDS_GPU_EXPORT STLReader
+class GRIDGENERATOR_EXPORT STLReader
 {
 public:
 
diff --git a/src/gpu/GridGenerator/io/STLReaderWriter/STLWriter.h b/src/gpu/GridGenerator/io/STLReaderWriter/STLWriter.h
index bd5aee2681aace14f82e328a9eeaafd621ae8482..c6185480237cf5a8dab0fc8c9b71044a420fd70c 100644
--- a/src/gpu/GridGenerator/io/STLReaderWriter/STLWriter.h
+++ b/src/gpu/GridGenerator/io/STLReaderWriter/STLWriter.h
@@ -11,7 +11,7 @@
 class Transformator;
 struct Triangle;
 
-class VIRTUALFLUIDS_GPU_EXPORT STLWriter
+class GRIDGENERATOR_EXPORT STLWriter
 {
 public:
     static void writeSTL(std::vector<Triangle> &vec, const std::string &name, bool writeBinary = false);
diff --git a/src/gpu/GridGenerator/io/SimulationFileWriter/SimulationFileNames.h b/src/gpu/GridGenerator/io/SimulationFileWriter/SimulationFileNames.h
index b794a2d49e9786ee28b68cb0a4494be02edfb006..fdc09047f7037d60df1f3de5c33be57137c06286 100644
--- a/src/gpu/GridGenerator/io/SimulationFileWriter/SimulationFileNames.h
+++ b/src/gpu/GridGenerator/io/SimulationFileWriter/SimulationFileNames.h
@@ -5,7 +5,7 @@
 
 #include "global.h"
 
-struct VIRTUALFLUIDS_GPU_EXPORT simulationFileNames
+struct GRIDGENERATOR_EXPORT simulationFileNames
 {
 	static const std::string coordX;
 	static const std::string coordY;
diff --git a/src/gpu/GridGenerator/io/SimulationFileWriter/SimulationFileWriter.h b/src/gpu/GridGenerator/io/SimulationFileWriter/SimulationFileWriter.h
index 8e50697e2b37a6a9350e62bc59ca112da59982da..eb10c9c107bb8e777e6f9a5d7bb4a57d021266fe 100644
--- a/src/gpu/GridGenerator/io/SimulationFileWriter/SimulationFileWriter.h
+++ b/src/gpu/GridGenerator/io/SimulationFileWriter/SimulationFileWriter.h
@@ -25,7 +25,7 @@ enum class FILEFORMAT
 class SimulationFileWriter : private NonCreatable
 {
 public:
-    VIRTUALFLUIDS_GPU_EXPORT static void write(std::string folder, SPtr<GridBuilder> builder, FILEFORMAT format);
+    GRIDGENERATOR_EXPORT static void write(std::string folder, SPtr<GridBuilder> builder, FILEFORMAT format);
 
 private:
     static void write(SPtr<GridBuilder> builder, FILEFORMAT format);
diff --git a/src/gpu/GridGenerator/io/VTKWriterWrapper/PolyDataWriterWrapper.h b/src/gpu/GridGenerator/io/VTKWriterWrapper/PolyDataWriterWrapper.h
index 19a70bb42308d24cb9b5807da8b442d1be7bd2a9..c7b3829d65db5520ee0170897d46c540dedcdb24 100644
--- a/src/gpu/GridGenerator/io/VTKWriterWrapper/PolyDataWriterWrapper.h
+++ b/src/gpu/GridGenerator/io/VTKWriterWrapper/PolyDataWriterWrapper.h
@@ -11,11 +11,11 @@
 //class PolyDataWriterWrapper
 //{
 //public:
-//	VIRTUALFLUIDS_GPU_EXPORT PolyDataWriterWrapper();
-//	VIRTUALFLUIDS_GPU_EXPORT ~PolyDataWriterWrapper();
+//	GRIDGENERATOR_EXPORT PolyDataWriterWrapper();
+//	GRIDGENERATOR_EXPORT ~PolyDataWriterWrapper();
 //
-//	VIRTUALFLUIDS_GPU_EXPORT virtual void addVectorArrow(std::shared_ptr<const Arrow> arrow);
-//	VIRTUALFLUIDS_GPU_EXPORT virtual void writePolyDataToFile(const std::string &filename) const;
+//	GRIDGENERATOR_EXPORT virtual void addVectorArrow(std::shared_ptr<const Arrow> arrow);
+//	GRIDGENERATOR_EXPORT virtual void writePolyDataToFile(const std::string &filename) const;
 //
 //private:
 //    std::shared_ptr<PolyDataWriter> writer;
diff --git a/src/gpu/GridGenerator/io/VTKWriterWrapper/UnstructuredGridWrapper.h b/src/gpu/GridGenerator/io/VTKWriterWrapper/UnstructuredGridWrapper.h
index a02a04f95db5fab74a1aac115d874580aa26bec5..6e13ba9ddfcb2ccce633f700ad04e0ec27642f4f 100644
--- a/src/gpu/GridGenerator/io/VTKWriterWrapper/UnstructuredGridWrapper.h
+++ b/src/gpu/GridGenerator/io/VTKWriterWrapper/UnstructuredGridWrapper.h
@@ -13,7 +13,7 @@
 //struct Vertex;
 //class Grid;
 //
-//class VIRTUALFLUIDS_GPU_EXPORT UnstructuredGridWrapper
+//class GRIDGENERATOR_EXPORT UnstructuredGridWrapper
 //{
 //public:
 //    UnstructuredGridWrapper();
diff --git a/src/gpu/GridGenerator/utilities/cuda/LaunchParameter.cuh b/src/gpu/GridGenerator/utilities/cuda/LaunchParameter.cuh
index e50318ed77c50f43994fb7e97fa32be52770cde8..20406fdb5f048d65a73dd55eec2dd3b31b11a76c 100644
--- a/src/gpu/GridGenerator/utilities/cuda/LaunchParameter.cuh
+++ b/src/gpu/GridGenerator/utilities/cuda/LaunchParameter.cuh
@@ -11,10 +11,10 @@
 class LaunchParameter
 {
 public:
-	CUDA_HOST VIRTUALFLUIDS_GPU_EXPORT LaunchParameter();
+	CUDA_HOST GRIDGENERATOR_EXPORT LaunchParameter();
 
-	CUDA_HOST VIRTUALFLUIDS_GPU_EXPORT static LaunchParameter make_2D1D_launchParameter(int size, int threadDim);
-	CUDA_HOST VIRTUALFLUIDS_GPU_EXPORT static LaunchParameter make_1D1D_launchParameter(int size, int threadDim);
+	CUDA_HOST GRIDGENERATOR_EXPORT static LaunchParameter make_2D1D_launchParameter(int size, int threadDim);
+	CUDA_HOST GRIDGENERATOR_EXPORT static LaunchParameter make_1D1D_launchParameter(int size, int threadDim);
 
 	DEVICE static int getGlobalIdx_2D_1D();
 	DEVICE static int getGlobalIdx_1D_1D();
diff --git a/src/gpu/GridGenerator/utilities/math/Math.h b/src/gpu/GridGenerator/utilities/math/Math.h
index 8bf90f83ad9855ada90cf9bfd0076335454c18c5..b47f03b07fbcd04cbd2e5337882aa197e33ca7b5 100644
--- a/src/gpu/GridGenerator/utilities/math/Math.h
+++ b/src/gpu/GridGenerator/utilities/math/Math.h
@@ -11,7 +11,7 @@
 
 namespace vf 
 {
-    class VIRTUALFLUIDS_GPU_EXPORT Math
+    class GRIDGENERATOR_EXPORT Math
     {
     public:
         HOSTDEVICE static bool equal(const real& val1, const real& val2, real maxRelDiff = EPSILON);
diff --git a/src/gpu/GridGenerator/utilities/transformator/ArrowTransformator.h b/src/gpu/GridGenerator/utilities/transformator/ArrowTransformator.h
index 8048fb93649812c73ca089f82a211eaa52f9e193..186b66838c3aa7398a7fc8a494c3f41372c30727 100644
--- a/src/gpu/GridGenerator/utilities/transformator/ArrowTransformator.h
+++ b/src/gpu/GridGenerator/utilities/transformator/ArrowTransformator.h
@@ -10,7 +10,7 @@ class Arrow;
 class ArrowTransformator
 {
 public:
-    static VIRTUALFLUIDS_GPU_EXPORT std::shared_ptr<ArrowTransformator> makeTransformator(real delta, real dx, real dy, real dz);
+    static GRIDGENERATOR_EXPORT std::shared_ptr<ArrowTransformator> makeTransformator(real delta, real dx, real dy, real dz);
 	virtual ~ArrowTransformator() {}
 
 protected:
diff --git a/src/gpu/GridGenerator/utilities/transformator/Transformator.h b/src/gpu/GridGenerator/utilities/transformator/Transformator.h
index 24d57e91ab59f9c129c902b7c008f572c80fd96b..0f092ddb90ce0ea60aed6b17edc415596669422c 100644
--- a/src/gpu/GridGenerator/utilities/transformator/Transformator.h
+++ b/src/gpu/GridGenerator/utilities/transformator/Transformator.h
@@ -14,7 +14,7 @@ struct Vertex;
 class Transformator
 {
 public:
-    static VIRTUALFLUIDS_GPU_EXPORT std::shared_ptr<Transformator> makeTransformator(real delta, real dx, real dy, real dz);
+    static GRIDGENERATOR_EXPORT std::shared_ptr<Transformator> makeTransformator(real delta, real dx, real dy, real dz);
 	virtual ~Transformator() {}
 
 protected:
diff --git a/src/gpu/GridGenerator/utilities/transformator/TransformatorImp.h b/src/gpu/GridGenerator/utilities/transformator/TransformatorImp.h
index ec5caefd8c3b85cb3a0d0ace78cee80a7e9deb67..f2e68bc131d7e80e4777ab0ac3ac003e203633a8 100644
--- a/src/gpu/GridGenerator/utilities/transformator/TransformatorImp.h
+++ b/src/gpu/GridGenerator/utilities/transformator/TransformatorImp.h
@@ -5,6 +5,7 @@
 #include <sstream>
 
 #include "global.h"
+#include "GridGenerator_export.h"
 
 #include "utilities/transformator/Transformator.h"
 #include "utilities/transformator/ArrowTransformator.h"
@@ -27,25 +28,25 @@ class TransformatorImp
 	: public Transformator, public ArrowTransformator
 {
 public:
-	VIRTUALFLUIDS_GPU_EXPORT TransformatorImp();
-	VIRTUALFLUIDS_GPU_EXPORT TransformatorImp(const TransformatorImp& trafo);
-	VIRTUALFLUIDS_GPU_EXPORT TransformatorImp(real delta, const Vertex& translater);
-	VIRTUALFLUIDS_GPU_EXPORT TransformatorImp(real delta, real dx, real dy, real dz);
-	VIRTUALFLUIDS_GPU_EXPORT virtual ~TransformatorImp();
+	GRIDGENERATOR_EXPORT TransformatorImp();
+	GRIDGENERATOR_EXPORT TransformatorImp(const TransformatorImp& trafo);
+	GRIDGENERATOR_EXPORT TransformatorImp(real delta, const Vertex& translater);
+	GRIDGENERATOR_EXPORT TransformatorImp(real delta, real dx, real dy, real dz);
+	GRIDGENERATOR_EXPORT virtual ~TransformatorImp();
 	
-	VIRTUALFLUIDS_GPU_EXPORT void transformWorldToGrid(Triangle &value) const;
-	VIRTUALFLUIDS_GPU_EXPORT void transformWorldToGrid(TriangularMesh &geom) const;
-	VIRTUALFLUIDS_GPU_EXPORT void transformWorldToGrid(Vertex &value) const;
+	GRIDGENERATOR_EXPORT void transformWorldToGrid(Triangle &value) const;
+	GRIDGENERATOR_EXPORT void transformWorldToGrid(TriangularMesh &geom) const;
+	GRIDGENERATOR_EXPORT void transformWorldToGrid(Vertex &value) const;
 
-    VIRTUALFLUIDS_GPU_EXPORT void transformGridToWorld(Triangle &t) const;
-	VIRTUALFLUIDS_GPU_EXPORT void transformGridToWorld(Vertex &value) const;
+    GRIDGENERATOR_EXPORT void transformGridToWorld(Triangle &t) const;
+	GRIDGENERATOR_EXPORT void transformGridToWorld(Vertex &value) const;
 
-	VIRTUALFLUIDS_GPU_EXPORT void transformGridToWorld(BoundingBox &box) const;
-	VIRTUALFLUIDS_GPU_EXPORT void transformWorldToGrid(BoundingBox &box) const;
+	GRIDGENERATOR_EXPORT void transformGridToWorld(BoundingBox &box) const;
+	GRIDGENERATOR_EXPORT void transformWorldToGrid(BoundingBox &box) const;
 
-	VIRTUALFLUIDS_GPU_EXPORT bool operator==(const TransformatorImp& trafo) const;
+	GRIDGENERATOR_EXPORT bool operator==(const TransformatorImp& trafo) const;
 
-	VIRTUALFLUIDS_GPU_EXPORT virtual void transformGridToWorld(std::shared_ptr<Arrow> arrow) const override;
+	GRIDGENERATOR_EXPORT virtual void transformGridToWorld(std::shared_ptr<Arrow> arrow) const override;
 
 private:
 	real delta;