diff --git a/lib/agent/experimental/CSV_Writer.cpp b/lib/agent/experimental/CSV_Writer.cpp
index f12e605..d3b55fd 100644
--- a/lib/agent/experimental/CSV_Writer.cpp
+++ b/lib/agent/experimental/CSV_Writer.cpp
@@ -1,86 +1,92 @@
 #include "rosa/agent/experimental/CSV_Writer.hpp"
 //#include <string>
 //#include <iostream>
 
 #define STRINGLENGTH 5000
 
 void CSV_Writer :: initialize_csv_writer(char* filepath_write) {
 	//fpointer_write = fopen(filepath_write, "w");
-	fopen_s(&fpointer_write, filepath_write, "w");
-
+#if defined (_WIN64) || (__WIN32__) || (_WIN32)                 
+    fopen_s(&fpointer_write, filepath_write, "w");
+#elif defined(__linux__)
+    fpointer_write = fopen(filepath_write, "w");
+    if (fpointer_write == NULL) {
+        printf("Parth: %s not found \n", filepath_write);
+    }
+#endif 
 	//if (fpointer_write == NULL) {
 		//printf("Path: %s", filepath_write);
 	//}
 }
 
 CSV_Writer :: CSV_Writer(char* filepath_write) {
 	set_name((char *)NO_NAME);
 	initialize_csv_writer(filepath_write);
 }
 
 CSV_Writer :: CSV_Writer(char* name, char* filepath_write) {
 	set_name(name);
 	initialize_csv_writer(filepath_write);
 }
 
 
 
 bool CSV_Writer :: write_field(int dataset) {
 	if(fpointer_write) {
 		fprintf(fpointer_write, "%i", dataset);		
 		return true;
 	}
 	return false;
 }
 
 bool CSV_Writer :: write_field(float dataset) {
 	if(fpointer_write) {
 		fprintf(fpointer_write, "%f", dataset);		
 		return true;
 	}
 	return false;
 }
 
 bool CSV_Writer :: write_field(char* dataset) {
 	if(fpointer_write) {
 		fprintf(fpointer_write, "%s", dataset);		
 		return true;
 	}
 	return false;
 }
 
 bool CSV_Writer :: make_new_field() {
 	if(fpointer_write) {
 		fprintf(fpointer_write, ",");		
 		return true;
 	}
 	return false;
 }
 
 bool CSV_Writer :: make_new_line() {
 	if(fpointer_write) {
 		fprintf(fpointer_write, "\n");	
 		return true;
 	}
 	return false;
 }
 
 
 bool CSV_Writer :: write_row_data(unsigned int num_of_datasets, float* datasets) {
 	
 	if(fpointer_write) {
 		for(unsigned int d_ix=0; d_ix<num_of_datasets; d_ix++) {
 			fprintf(fpointer_write, "%f", datasets[d_ix]);
 			if(d_ix < num_of_datasets-1)
 				fprintf(fpointer_write, ",");
 		}
 		fprintf(fpointer_write, "\n");		
 		return true;
 	}
 	return false;
 }
 
 void CSV_Writer :: close_file() {
 	if(fpointer_write)
 		fclose(fpointer_write); 
 }
diff --git a/lib/agent/experimental/CSVreaderModule.cpp b/lib/agent/experimental/CSVreaderModule.cpp
index a4899b1..8a6d8c6 100644
--- a/lib/agent/experimental/CSVreaderModule.cpp
+++ b/lib/agent/experimental/CSVreaderModule.cpp
@@ -1,192 +1,215 @@
 #include "rosa/agent/experimental/CSVreaderModule.hpp"
 #include <string>
 #include <iostream>
+#include <string.h>
 
 #define STRINGLENGTH 5000
 
 /*
 void CSV_Reader :: initialize_csvreader(char* filepath_read, unsigned int num_of_datasets, unsigned int* list_of_datasets, unsigned int start_row) {
 	//fpointer_read = fopen(filepath_read, "r");
 	fopen_s(&fpointer_read, filepath_read, "r");
 
 	this->num_of_datasets = num_of_datasets;
 	//TODO: sort.. falls es nicht in aufsteigender folge kommt
 	for(unsigned int d_ix=0; d_ix<num_of_datasets; d_ix++) {
 		this->list_of_datasets[d_ix] = list_of_datasets[d_ix];
 	}
 
 	row = 1;
 	this->start_row = start_row;
 }
 */
 
  void CSVreaderModule :: initialize_csvreader(FILE* fpointer, unsigned int column, unsigned int start_row) {
 	//fpointer_read = fopen(filepath_read, "r");
 	
 	//TODO: file ponter schon aus CSV-Reader Creator Funktion übergeben.. dann kann man nämlich ausgeben, wenn da was nicht erstellt werden kann
 	//bool file_opened = fopen_s(&fpointer_read, filepath_read, "r");
 	//TODO: etwas mit flag
 
 	this->fpointer = fpointer;
 	this->row = 1;
 	this->column = column;
 	this->start_row = start_row;
 	
 	flag_csv_reader_configured = true;
 }
 
 
 /*
 CSV_Reader :: CSV_Reader(char* filepath_read, unsigned int num_of_data_sets, unsigned int* list_of_datasets, unsigned int start_row) {
 	set_name(NO_NAME);
 	initialize_csvreader(filepath_read, num_of_data_sets, list_of_datasets, start_row);
 }
 
 CSV_Reader :: CSV_Reader(char* name, char* filepath_read, unsigned int num_of_data_sets, unsigned int* list_of_datasets, unsigned int start_row) {
 	set_name(name);
 	initialize_csvreader(filepath_read, num_of_data_sets, list_of_datasets, start_row);
 }
 */
 
 CSVreaderModule :: CSVreaderModule() {
 	set_name((char *)NO_NAME);
 	flag_csv_reader_configured = false;
 }
 
 CSVreaderModule :: CSVreaderModule(char* name) {
 	set_name(name);
 	flag_csv_reader_configured = false;
 }
 
 CSVreaderModule :: CSVreaderModule(FILE* fpointer, unsigned int column, unsigned int start_row) {
 	set_name((char *)NO_NAME);
 	
 	if(fpointer) {
 		initialize_csvreader(fpointer, column, start_row);
 	}
 	else {
 		flag_csv_reader_configured = false;
 	}
 }
 
 CSVreaderModule :: CSVreaderModule(char* name, FILE* fpointer, unsigned int column, unsigned int start_row) {
 	set_name(name);
 
 	if(fpointer) {
 		initialize_csvreader(fpointer, column, start_row);
 	}
 	else {
 		flag_csv_reader_configured = false;
 	}
 }
 /*
 CSV_Reader :: CSV_Reader(char* name, char* filepath_read, int column, int start_row) {
 
 }
 */
 
 
 
 //XXX: Wird nicht mehr benutzt
 //TODO: überarbeiten nach folgendem Beispiel https://msdn.microsoft.com/en-us/library/ftsafwz3.aspx
 bool CSVreaderModule :: read_one_row() {
 	if(fpointer)
 	{ 
         char readrow[STRINGLENGTH] = "";//, electedfield[STRINGLENGTH] = ""; 
 
 		//TODO: move following for-loop to "initialize_csvreader(...)
 		for(;row<start_row; row++) {
 
 			if(!fgets(readrow, STRINGLENGTH, fpointer))
 				return false;
 		}
 
 		if(fgets (readrow, STRINGLENGTH, fpointer))
 		{
+            char del[] = ",;";
 			char *ptr, *next_ptr;
 			//TODO: make delimiter configurable!
-			ptr = strtok_s(readrow, ",;", &next_ptr);
+#if defined (_WIN64) || (__WIN32__) || (_WIN32) 
+			ptr = strtok_s(readrow, del, &next_ptr);
+#elif defined(__linux__)
+            ptr = strtok_r(readrow, del, &next_ptr);
+#endif
 			//OLD: unsigned int dataset_counter = 0;
 			dataset_counter = 0;
 
 			if(list_of_datasets[dataset_counter] == 1) {
 				data_read[dataset_counter] = std::stof(ptr, NULL);
 				dataset_counter++;
 			}
 			else {
-				ptr = strtok_s(NULL, ",;", &next_ptr);
+#if defined (_WIN64) || (__WIN32__) || (_WIN32)                 
+				ptr = strtok_s(NULL, del, &next_ptr);
+#elif defined(__linux__)
+                ptr = strtok_r(readrow, del, &next_ptr);
+#endif                
 			}
 
 			for(;dataset_counter<num_of_datasets;dataset_counter++) {
 				for(unsigned int c_ix=list_of_datasets[dataset_counter-1]; c_ix<list_of_datasets[dataset_counter]; c_ix++)
 				{
-					ptr = strtok_s(NULL, ",;", &next_ptr);	
+#if defined (_WIN64) || (__WIN32__) || (_WIN32)                 
+                    ptr = strtok_s(NULL, del, &next_ptr);
+#elif defined(__linux__)
+                    ptr = strtok_r(readrow, del, &next_ptr);
+#endif  
 				}
 				data_read[dataset_counter] = std::stof(ptr, NULL);
 			}
 			return true;
 		}
 	}
 	return false;
 }
 
 float CSVreaderModule :: get_value_of_field(unsigned int field) {
 	//TODO: Bessere Fehlerbehandlung.. also nciht einfach 0 returnen, wenn kein richtiges FEld!!!
 	if(field < num_of_datasets) {
 		return data_read[field];
 	}
 
 	return 0.0;
 }
 
 
 
 //TODO: überarbeiten nach folgendem Beispiel https://msdn.microsoft.com/en-us/library/ftsafwz3.aspx
 bool CSVreaderModule :: read_field() {
 	if(fpointer)
 	{ 
         char readrow[STRINGLENGTH] = "";//, electedfield[STRINGLENGTH] = ""; 
 
 		//TODO: move following for-loop to "initialize_csvreader(...)
 		for(;row<start_row; row++) {
 
 			if(!fgets(readrow, STRINGLENGTH, fpointer))
 				return false;
 		}
 
 		if(fgets (readrow, STRINGLENGTH, fpointer))
 		{
+            char del[] = ",;";
 			char *ptr, *next_ptr;
 			//TODO: make delimiter configurable!
-			ptr = strtok_s(readrow, ",;", &next_ptr);
+#if defined (_WIN64) || (__WIN32__) || (_WIN32)                 
+            ptr = strtok_s(NULL, del, &next_ptr);
+#elif defined(__linux__)
+            ptr = strtok_r(readrow, del, &next_ptr);
+#endif 
 			
 			for(unsigned int d_ix=1; d_ix<column; d_ix++) {
-				ptr = strtok_s(NULL, ",;", &next_ptr);	
+#if defined (_WIN64) || (__WIN32__) || (_WIN32)                 
+                ptr = strtok_s(NULL, del, &next_ptr);
+#elif defined(__linux__)
+                ptr = strtok_r(readrow, del, &next_ptr);
+#endif 
 			}
 			
 			input_data = std::stof(ptr, NULL);
 			return true;
 		}
 	}
 	return false;
 }
 
 
 bool CSVreaderModule :: get_next_value(float* value) {
 
 	if(flag_csv_reader_configured) {
 
 		if(read_field()) {
 
 			*value = input_data;
 			return true;
 		}
 	}
 
 	return false;
 }
 
 //TODO: flag_csv_reader_configured abfragen
 void CSVreaderModule :: close_file() {
 	fclose(fpointer); 
 }
diff --git a/lib/agent/experimental/Module.cpp b/lib/agent/experimental/Module.cpp
index ba223ac..3625481 100644
--- a/lib/agent/experimental/Module.cpp
+++ b/lib/agent/experimental/Module.cpp
@@ -1,19 +1,23 @@
 #include "rosa/agent/experimental/Module.hpp"
 #include <string.h>
 
 Module :: Module() {
 	set_name((char*)NO_NAME);
 }
 
 Module :: Module(char* name) {
 	set_name(name);
 }
 
 
 void Module :: set_name(char* name) {
-	strncpy_s (this->name, name, MAX_LENGTH_NAME);
+#if defined (_WIN64) || (__WIN32__) || (_WIN32)                 
+    strncpy_s (this->name, name, MAX_LENGTH_NAME);
+#elif defined(__linux__)
+	strncpy(this->name, name, MAX_LENGTH_NAME);
+#endif
 }
 
 char* Module :: get_name() {
 	return this->name;
-}
\ No newline at end of file
+}