diff --git a/CMakeLists.txt b/CMakeLists.txt
index e18fc73b..e031694e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -35,16 +35,17 @@ option(ICU "Unicode support" 1)
 option(USB "USB support" 0)
 option(STL "Building with STL containers" 0)
 option(CRYPT "Crypt support" 0)
-option(FFTW "fftw3 support for PIFFT" 1)
+option(FFTW "fftw3 support for PIFFT" 0)
+option(FFTW_THREADS "fftw3 support for threadsave" 1)
 option(INTROSPECTION_CONTAINERS "Build with containers introspection" 0)
 option(INTROSPECTION_THREADS "Build with threads introspection" 0)
 option(LIB "System install" 1)
 option(DEBUG "Build with -g3" 0)
 set(CMAKE_BUILD_TYPE "Release")
 set(LIBS)
-if (DEBUG)
+if(DEBUG)
 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g3")
-endif ()
+endif()
 
 # Sources
 set(PIP_FOLDERS "." "core" "containers" "thread" "system" "io" "console" "math" "code" "geo")
@@ -69,148 +70,168 @@ CHECK_FUNCTION_EXISTS(jn PIP_MATH_JN)
 CHECK_FUNCTION_EXISTS(y0 PIP_MATH_Y0)
 CHECK_FUNCTION_EXISTS(y1 PIP_MATH_Y1)
 CHECK_FUNCTION_EXISTS(yn PIP_MATH_YN)
-if (PIP_MATH_J0)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPIP_MATH_J0")
-endif ()
-if (PIP_MATH_J1)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPIP_MATH_J1")
-endif ()
-if (PIP_MATH_JN)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPIP_MATH_JN")
-endif ()
-if (PIP_MATH_Y0)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPIP_MATH_Y0")
-endif ()
-if (PIP_MATH_Y1)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPIP_MATH_Y1")
-endif ()
-if (PIP_MATH_YN)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPIP_MATH_YN")
-endif ()
+if(PIP_MATH_J0)
+	add_definitions(-DPIP_MATH_J0)
+endif()
+if(PIP_MATH_J1)
+	add_definitions(-DPIP_MATH_J1)
+endif()
+if(PIP_MATH_JN)
+	add_definitions(-DPIP_MATH_JN)
+endif()
+if(PIP_MATH_Y0)
+	add_definitions(-DPIP_MATH_Y0)
+endif()
+if(PIP_MATH_Y1)
+	add_definitions(-DPIP_MATH_Y1)
+endif()
+if(PIP_MATH_YN)
+	add_definitions(-DPIP_MATH_YN)
+endif()
 
+if(WIN32)
+	list(APPEND CMAKE_LIBRARY_PATH  ${MINGW_LIB})
+endif()
 
 # Check if RT timers exists
 set(CMAKE_REQUIRED_INCLUDES time.h)
-if (DEFINED ENV{QNX_HOST})
-	set(CMAKE_REQUIRED_LIBRARIES )
-else ()
-	set(CMAKE_REQUIRED_LIBRARIES rt)
-endif ()
+if(NOT DEFINED ENV{QNX_HOST} AND NOT APPLE AND NOT WIN32)
+	list(APPEND LIBS rt)
+endif()
 CHECK_FUNCTION_EXISTS(timer_create PIP_TIMER_RT_0)
 CHECK_FUNCTION_EXISTS(timer_settime PIP_TIMER_RT_1)
 CHECK_FUNCTION_EXISTS(timer_delete PIP_TIMER_RT_2)
-if (PIP_TIMER_RT_0 AND PIP_TIMER_RT_1 AND PIP_TIMER_RT_2)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPIP_TIMER_RT")
+if(PIP_TIMER_RT_0 AND PIP_TIMER_RT_1 AND PIP_TIMER_RT_2)
+	add_definitions(-DPIP_TIMER_RT)
 	message(STATUS "Available timers: Thread, ThreadRT, Pool")
-else ()
+else()
 	message(STATUS "Available timers: Thread, Pool")
-endif ()
+endif()
 
 
 # Check if USB is on (to enable use "-DUSB=" argument of cmake)
-if (USB)
+if(USB)
 	message(STATUS "Building with USB support")
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPIP_USB")
+	add_definitions(-DPIP_USB)
 	list(APPEND LIBS usb)
-else ()
+else()
 	message(STATUS "Building without USB support")
-endif ()
+endif()
 
 
 # Check if STL containers is on (to enable use "-DSTL=" argument of cmake)
-if (STL)
+if(STL)
 	message(STATUS "Building with STL containers")
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPIP_CONTAINERS_STL")
-else ()
+	add_definitions(-DPIP_CONTAINERS_STL)
+else()
 	message(STATUS "Building with PIP containers")
-endif ()
+endif()
 
 
 # Check if ICU used for PIString and PIChar
-if (ICU)
+if(ICU)
 	message(STATUS "Building with ICU")
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPIP_ICU")
+	add_definitions(-DPIP_ICU)
 	list(APPEND LIBS icuuc)
-else ()
+else()
 	message(STATUS "Building without ICU, attention!")
-endif ()
+endif()
 
 
 # Check if PIP support cryptographic encryption/decryption by using sodium library
-if (CRYPT)
+if(CRYPT)
 	message(STATUS "Building with crypt support")
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPIP_CRYPT")
+	add_definitions(-DPIP_CRYPT)
 	list(APPEND LIBS sodium)
-else ()
+else()
 	message(STATUS "Building without crypt support")
-endif ()
+endif()
 
 
 # Check if PIP support fftw3 for PIFFT using in math module
-if (FFTW)
+if(FFTW)
 	message(STATUS "Building with fftw3 support")
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPIP_FFTW")
-	if (WIN32)
+	add_definitions(-DPIP_FFTW)
+	if(WIN32)
+		add_definitions(-DPIP_FFTW_THREADSAFE)
 		list(APPEND LIBS fftw3-3 fftw3f-3 fftw3l-3)
-	else ()
-		list(APPEND LIBS fftw3 fftw3f fftw3_threads fftw3f_threads)
-	endif ()
-else ()
+	else()
+		list(APPEND LIBS fftw3 fftw3f)
+		if(FFTW_THREADS)
+			add_definitions(-DPIP_FFTW_THREADSAFE)
+			list(APPEND LIBS fftw3_threads fftw3f_threads)
+		endif()
+	endif()
+else()
 	message(STATUS "Building without fftw3 support")
-endif ()
+endif()
 
 
 # Check if PIP should be built with containers introspection
-if (INTROSPECTION_CONTAINERS)
+if(INTROSPECTION_CONTAINERS)
 	message(STATUS "Building with containers introspection")
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPIP_INTROSPECTION_CONTAINERS")
-else ()
+	add_definitions(-DPIP_INTROSPECTION_CONTAINERS)
+else()
 	message(STATUS "Building without containers introspection")
-endif ()
+endif()
 
 
 # Check if PIP should be built with threads introspection
-if (INTROSPECTION_THREADS)
+if(INTROSPECTION_THREADS)
 	message(STATUS "Building with threads introspection")
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPIP_INTROSPECTION_THREADS")
-else ()
+	add_definitions(-DPIP_INTROSPECTION_THREADS)
+else()
 	message(STATUS "Building without threads introspection")
-endif ()
+endif()
 
 
 # Add library
-if (APPLE)
+if(APPLE)
     add_definitions(-D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE)
-endif ()
-if (WIN32)
+endif()
+if(WIN32)
 	list(APPEND LIBS ws2_32 iphlpapi psapi)
+else()
+	list(APPEND LIBS dl)
+	if(DEFINED ENV{QNX_HOST})
+		list(APPEND LIBS socket)
+	else()
+		list(APPEND LIBS pthread util)
+	endif()
+endif()
+foreach(LIB_ ${LIBS})
+	find_library("${LIB_}_FOUND" ${LIB_})
+	message(STATUS "Check the ${LIB_} is installed: " ${${LIB_}_FOUND})
+	if("${${LIB_}_FOUND}" STREQUAL "${LIB_}_FOUND-NOTFOUND")
+		message(WARNING  "library ${LIB_} not found, please install it")
+	else()
+		list(APPEND LIBS ${LIB_})
+		list(APPEND CMAKE_REQUIRED_LIBRARIES ${LIB_})
+	endif()
+endforeach()
+if(WIN32)
 	list(APPEND CPPS "pip_resource_win.rc")
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPSAPI_VERSION=1")
+	add_definitions(-DPSAPI_VERSION=1)
 	add_library(pip SHARED ${CPPS} ${HDRS} ${PHDRS})
-	if (${CMAKE_C_COMPILER} STREQUAL "cl")
+	if(${CMAKE_C_COMPILER} STREQUAL "cl")
 		include(GenerateExportHeader)
 		generate_export_header(pip)
 		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /O2 /Ob2 /Ot")
-	else ()
-		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
+	else()
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -Wall")
 		#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
-	endif ()
-else ()
+	endif()
+else()
 	set(${CMAKE_CXX_FLAGS} "${CMAKE_CXX_FLAGS} -O3 -fPIC")
 	#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
-	if (DEFINED ENV{QNX_HOST})
-		list(APPEND LIBS socket dl)
+	if(DEFINED ENV{QNX_HOST})
 		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftemplate-depth-32")
 		add_library(pip STATIC ${CPPS})
-	else ()
-		list(APPEND LIBS pthread dl util)
-		if (NOT APPLE)
-			list(APPEND LIBS rt)
-		endif()
+	else()
 		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
 		add_library(pip SHARED ${CPPS})
-	endif ()
-endif ()
+	endif()
+endif()
 target_link_libraries(pip ${LIBS})
 
 # Test program
@@ -221,34 +242,34 @@ target_link_libraries(pip_test pip)# ${QT_QTCORE_LIBRARY})
 
 # Install
 # Check if system or local install will be used (to system install use "-DLIB=" argument of cmake)
-if (LIB)
-	if (WIN32)
-		if (MINGW)
+if(LIB)
+	if(WIN32)
+		if(MINGW)
 			find_package(MinGW REQUIRED)
 			set(CMAKE_INSTALL_PREFIX ${MINGW_DIR})
 			install(FILES ${HDRS} DESTINATION ${MINGW_INCLUDE}/pip)
 			install(TARGETS pip DESTINATION ${MINGW_LIB})
 			install(TARGETS pip DESTINATION ${MINGW_BIN})
-		endif ()
-	else ()
-		if (APPLE)
+		endif()
+	else()
+		if(APPLE)
 			set(CMAKE_INSTALL_PREFIX /usr/local)
 		else()
-                        set(CMAKE_INSTALL_PREFIX /usr)
+			set(CMAKE_INSTALL_PREFIX /usr)
 		endif()
 		install(FILES ${HDRS} DESTINATION ${CMAKE_INSTALL_PREFIX}/include/pip)
 		install(TARGETS pip DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
-	endif ()
+	endif()
 	message(STATUS "Install to system \"${CMAKE_INSTALL_PREFIX}\"")
 	# Precompiled header
 	#add_custom_target(pip_pch ALL COMMAND ${CMAKE_CXX_COMPILER} -O2 -fPIC -g3 ${CMAKE_INSTALL_PREFIX}/include/pip/pip.h DEPENDS pip SOURCES ${HDRS})
 	#list(APPEND HDRS "pip.h.gch")
 	file(GLOB CMAKES "*.cmake")
 	install(FILES ${CMAKES} DESTINATION ${CMAKE_ROOT}/Modules)
-else ()
+else()
 	install(TARGETS pip DESTINATION bin)
 	message(STATUS "Install to local \"bin\"")
-endif ()
+endif()
 
 # Auxiliary
 add_subdirectory("src/auxiliary/piterminal")
diff --git a/FindPIP.cmake b/FindPIP.cmake
index 8ac8be1f..526ce85f 100644
--- a/FindPIP.cmake
+++ b/FindPIP.cmake
@@ -1,21 +1,21 @@
-if (WIN32)
+if(WIN32)
 	find_package(MinGW REQUIRED)
 	find_library(PIP_LIBRARY pip ${MINGW_LIB})
 	set(PIP_INCLUDES ${MINGW_INCLUDE}/pip)
 	set(PIP_CMG ${MINGW_BIN}/pip_cmg.exe)
-else ()
+else()
 	find_library(PIP_LIBRARY pip /usr/lib/)
-	if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
+	if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
 		find_library(PTHREAD_LIBRARY pthread)
 		find_library(DL_LIBRARY dl)
 		find_library(UTIL_LIBRARY util)
 		list(APPEND PIP_LIBRARY ${PTHREAD_LIBRARY} ${DL_LIBRARY} ${UTIL_LIBRARY})
-	endif ()
+	endif()
 	set(PIP_INCLUDES /usr/include/pip)
 	set(PIP_CMG /usr/bin/pip_cmg)
-endif ()
+endif()
 
-if (NOT PIP_VERSION)
+if(NOT PIP_VERSION)
 	file(STRINGS "${PIP_INCLUDES}/pip_version_str.h" _VERSION REGEX "\".*\"")
 	string(REGEX MATCH "\".*\"" _VERSION ${_VERSION})
 	string(LENGTH ${_VERSION} SL)
@@ -23,10 +23,10 @@ if (NOT PIP_VERSION)
 	string(SUBSTRING ${_VERSION} 1 ${SL} _VERSION)
 	set(PIP_VERSION ${_VERSION} CACHE STRING "VERSION")
 	message(STATUS "Found PIP version ${PIP_VERSION}")
-endif ()
-if (PIP_FIND_VERSION VERSION_GREATER PIP_VERSION)
+endif()
+if(PIP_FIND_VERSION VERSION_GREATER PIP_VERSION)
 	message(FATAL_ERROR "PIP version ${PIP_VERSION} is available, but ${PIP_FIND_VERSION} requested!")
-endif ()
+endif()
 
 include(PIPMacros)
 
diff --git a/src/math/picrypt.cpp b/src/math/picrypt.cpp
index 3559f0d9..625fd8ac 100644
--- a/src/math/picrypt.cpp
+++ b/src/math/picrypt.cpp
@@ -28,8 +28,7 @@ const char hash_def_key[] = "_picrypt_";
 
 PICrypt::PICrypt() {
 #ifdef PIP_CRYPT
-	int ret;
-	ret = sodium_init();
+	sodium_init();
 	nonce_.resize(crypto_secretbox_NONCEBYTES);
 	key_.resize(crypto_secretbox_KEYBYTES);
 	randombytes_buf(key_.data(), key_.size());
@@ -78,8 +77,7 @@ PIByteArray PICrypt::crypt(const PIByteArray & data, PIByteArray key) {
 	if (key.size() != crypto_secretbox_KEYBYTES)
 		key.resize(crypto_secretbox_KEYBYTES, ' ');
 		//return PIByteArray();
-	int ret;
-	ret = sodium_init();
+	sodium_init();
 	PIByteArray n;
 	retba.resize(data.size() + crypto_secretbox_MACBYTES);
 	n.resize(crypto_secretbox_NONCEBYTES);
@@ -125,8 +123,7 @@ PIByteArray PICrypt::decrypt(const PIByteArray & crypt_data, PIByteArray key, bo
 		if (ok) *ok = false;
 		return PIByteArray();
 	}
-	int ret;
-	ret = sodium_init();
+	sodium_init();
 	PIByteArray n;
 	n.resize(crypto_secretbox_NONCEBYTES);
 	retba.resize(crypt_data.size() - n.size() - crypto_secretbox_MACBYTES);
@@ -147,8 +144,7 @@ PIByteArray PICrypt::decrypt(const PIByteArray & crypt_data, PIByteArray key, bo
 PIByteArray PICrypt::hash(const PIString & secret) {
 	PIByteArray hash;
 #ifdef PIP_CRYPT
-	int ret;
-	ret = sodium_init();
+	sodium_init();
 	hash.resize(crypto_generichash_BYTES);
 	PIByteArray s(secret.data(), secret.size());
 	crypto_generichash(hash.data(), hash.size(), s.data(), s.size(), (const uchar*)hash_def_key, sizeof(hash_def_key) - 1);
@@ -163,8 +159,7 @@ ullong PICrypt::shorthash(const PIString& s, PIByteArray key) {
 	ullong hash = 0;
 #ifdef PIP_CRYPT
 	if (crypto_shorthash_BYTES != sizeof(hash)) piCout << "[PICrypt]" << "internal error: bad hash size";
-	int ret;
-	ret = sodium_init();
+	sodium_init();
 	if (key.size() != crypto_shorthash_KEYBYTES) {
 		piCout << "[PICrypt]" << "invalid key size" << key.size() << ", shoud be" << crypto_shorthash_KEYBYTES << ", filled zeros";
 		key.resize(crypto_shorthash_KEYBYTES, 0);
@@ -181,8 +176,7 @@ ullong PICrypt::shorthash(const PIString& s, PIByteArray key) {
 PIByteArray PICrypt::generateKey() {
 	PIByteArray hash;
 #ifdef PIP_CRYPT
-	int ret;
-	ret = sodium_init();
+	sodium_init();
 	hash.resize(crypto_secretbox_KEYBYTES);
 	randombytes_buf(hash.data(), hash.size());
 #else
diff --git a/src/math/pifft_p.h b/src/math/pifft_p.h
index 439781fb..6b634a6d 100644
--- a/src/math/pifft_p.h
+++ b/src/math/pifft_p.h
@@ -168,7 +168,9 @@ template<> inline void PIFFTW_Private<float>::p_executePlan(void * plan) {fftwf_
 template<> inline void PIFFTW_Private<float>::p_executePlan_c2c(void * plan, const void * in, void * out) {fftwf_execute_dft((fftwf_plan)plan, (fftwf_complex *)in, (fftwf_complex *)out);}
 template<> inline void PIFFTW_Private<float>::p_executePlan_r2c(void * plan, const void * in, void * out) {fftwf_execute_dft_r2c((fftwf_plan)plan, (float *)in, (fftwf_complex *)out);}
 template<> inline void PIFFTW_Private<float>::p_destroyPlan(void *& plan) {if (plan) fftwf_destroy_plan((fftwf_plan)plan); plan = 0;}
+#ifdef PIP_FFTW_THREADSAFE
 template<> inline void PIFFTW_Private<float>::p_makeThreadSafe() {fftwf_make_planner_thread_safe();}
+#endif
 
 template<> inline void PIFFTW_Private<double>::p_createPlan_c2c_1d(void *& plan, int size, const void * in, void * out, int dir, int flags) {
 	plan = fftw_plan_dft_1d(size, (fftw_complex *)in, (fftw_complex *)out, dir, flags);}
@@ -178,7 +180,9 @@ template<> inline void PIFFTW_Private<double>::p_executePlan(void * plan) {fftw_
 template<> inline void PIFFTW_Private<double>::p_executePlan_c2c(void * plan, const void * in, void * out) {fftw_execute_dft((fftw_plan)plan, (fftw_complex *)in, (fftw_complex *)out);}
 template<> inline void PIFFTW_Private<double>::p_executePlan_r2c(void * plan, const void * in, void * out) {fftw_execute_dft_r2c((fftw_plan)plan, (double *)in, (fftw_complex *)out);}
 template<> inline void PIFFTW_Private<double>::p_destroyPlan(void *& plan) {if (plan) fftw_destroy_plan((fftw_plan)plan); plan = 0;}
+#ifdef PIP_FFTW_THREADSAFE
 template<> inline void PIFFTW_Private<double>::p_makeThreadSafe() {fftw_make_planner_thread_safe();}
+#endif
 
 #ifdef WINDOWS
 template<> inline void PIFFTW_Private<ldouble>::p_createPlan_c2c_1d(void *& plan, int size, const void * in, void * out, int dir, int flags) {
@@ -189,7 +193,9 @@ template<> inline void PIFFTW_Private<ldouble>::p_executePlan(void * plan) {fftw
 template<> inline void PIFFTW_Private<ldouble>::p_executePlan_c2c(void * plan, const void * in, void * out) {fftwl_execute_dft((fftwl_plan)plan, (fftwl_complex *)in, (fftwl_complex *)out);}
 template<> inline void PIFFTW_Private<ldouble>::p_executePlan_r2c(void * plan, const void * in, void * out) {fftwl_execute_dft_r2c((fftwl_plan)plan, (ldouble *)in, (fftwl_complex *)out);}
 template<> inline void PIFFTW_Private<ldouble>::p_destroyPlan(void *& plan) {if (plan) fftwl_destroy_plan((fftwl_plan)plan); plan = 0;}
+#ifdef PIP_FFTW_THREADSAFE
 template<> inline void PIFFTW_Private<ldouble>::p_makeThreadSafe() {fftwl_make_planner_thread_safe();}
+#endif
 #endif // WINDOWS