diff --git a/ememory/SharedPtr.hpp b/ememory/SharedPtr.hpp
index 511514a..96e5460 100644
--- a/ememory/SharedPtr.hpp
+++ b/ememory/SharedPtr.hpp
@@ -65,7 +65,7 @@ namespace ememory {
 			#endif
 		public:
 			/**
-			 * @brief Contructor on nullptr
+			 * @brief Contructor on null
 			 */
 			SharedPtr(etk::NullPtr);
 			/**
@@ -99,7 +99,7 @@ namespace ememory {
 			 */
 			SharedPtr& operator= (const SharedPtr<EMEMORY_TYPE>& _obj);
 			/**
-			 * @brief Asignement operator (asign nullptr)
+			 * @brief Asignement operator (asign null)
 			 * @return Reference on this
 			 */
 			SharedPtr& operator= (etk::NullPtr);
@@ -125,7 +125,7 @@ namespace ememory {
 			 */
 			int64_t useCount() const;
 			/**
-			 * @brief Check if the SharedPtr have an internal data (not nullptr)
+			 * @brief Check if the SharedPtr have an internal data (not null)
 			 * @return true The pointer is not asigned, false otherwise
 			 */
 			bool operator==(etk::NullPtr) const;
@@ -137,7 +137,7 @@ namespace ememory {
 			template<class EMEMORY_TYPE2>
 			bool operator==(const SharedPtr<EMEMORY_TYPE2>& _obj) const;
 			/**
-			 * @brief Check if the SharedPtr have NOT an internal data (nullptr)
+			 * @brief Check if the SharedPtr have NOT an internal data (null)
 			 * @return true The pointer is asigned, false otherwise
 			 */
 			bool operator!=(etk::NullPtr) const;
diff --git a/ememory/UniquePtr.hpp b/ememory/UniquePtr.hpp
index 059f7dd..a103267 100644
--- a/ememory/UniquePtr.hpp
+++ b/ememory/UniquePtr.hpp
@@ -19,13 +19,13 @@ namespace ememory {
 			UniquePtr &operator=(UniquePtr<EMEM_UPTR_TYPE_2> &) = delete;
 		public:
 			UniquePtr() :
-			  m_pointer(nullptr),
-			  m_deleter(nullptr) {
+			  m_pointer(null),
+			  m_deleter(null) {
 				
 			}
 			UniquePtr(etk::NullPtr) :
-			  m_pointer(nullptr),
-			  m_deleter(nullptr) {
+			  m_pointer(null),
+			  m_deleter(null) {
 				
 			}
 			explicit UniquePtr(EMEM_UPTR_TYPE* _obj, deleterCall&& _deleter = [](void* _data) { ETK_DELETE(EMEM_UPTR_TYPE, _data);}) :
@@ -35,8 +35,8 @@ namespace ememory {
 			}
 			template <class EMEM_UPTR_TYPE_2>
 			UniquePtr(UniquePtr<EMEM_UPTR_TYPE_2>&& _obj) :
-			  m_pointer(nullptr),
-			  m_deleter(nullptr) {
+			  m_pointer(null),
+			  m_deleter(null) {
 				etk::swap(_obj.m_pointer, m_pointer);
 				etk::swap(_obj.m_deleter, m_deleter);
 			}
@@ -58,7 +58,7 @@ namespace ememory {
 			UniquePtr& operator=(UniquePtr<EMEM_UPTR_TYPE_2>& _obj){
 				reset();
 				m_pointer = _obj.m_pointer;
-				_obj.m_pointer = nullptr;
+				_obj.m_pointer = null;
 				return *this;
 			}*/
 			const EMEM_UPTR_TYPE& operator*() const {
@@ -78,32 +78,32 @@ namespace ememory {
 			}
 			EMEM_UPTR_TYPE *release(){
 				EMEM_UPTR_TYPE *tmp = m_pointer;
-				m_pointer = nullptr;
+				m_pointer = null;
 				return tmp;
 			}
 			void reset(){
-				if (m_deleter != nullptr) {
+				if (m_deleter != null) {
 					m_deleter(m_pointer);
 				}
-				m_pointer = nullptr;
+				m_pointer = null;
 			}
 			void swap(UniquePtr &_obj){
 				etk::swap(_obj.m_pointer, m_pointer);
 				etk::swap(_obj.m_deleter, m_deleter);
 			}
 			/**
-			 * @brief Check if the UniquePtr have an internal data (not nullptr)
+			 * @brief Check if the UniquePtr have an internal data (not null)
 			 * @return true The pointer is not asigned, false otherwise
 			 */
 			bool operator==(etk::NullPtr) const {
-				return m_pointer == nullptr;
+				return m_pointer == null;
 			}
 			/**
-			 * @brief Check if the UniquePtr have not an internal data (equal nullptr)
+			 * @brief Check if the UniquePtr have not an internal data (equal null)
 			 * @return true The pointer is asigned, false otherwise
 			 */
 			bool operator!=(etk::NullPtr) const {
-				return m_pointer != nullptr;
+				return m_pointer != null;
 			}
 			/*
 			template <class EMEM_UPTR_TYPE_2>
diff --git a/ememory/WeakPtr.hpp b/ememory/WeakPtr.hpp
index eb9d6e4..69bd48f 100644
--- a/ememory/WeakPtr.hpp
+++ b/ememory/WeakPtr.hpp
@@ -29,7 +29,7 @@ namespace ememory {
 			 */
 			WeakPtr();
 			/**
-			 * @brief nullptr contructor
+			 * @brief null contructor
 			 */
 			WeakPtr(etk::NullPtr);
 		private:
@@ -68,7 +68,7 @@ namespace ememory {
 			 */
 			WeakPtr<EMEMORY_TYPE>& operator= (const SharedPtr<EMEMORY_TYPE>& _obj);
 			/**
-			 * @brief nullptr asignement
+			 * @brief null asignement
 			 * @return Reference on this
 			 */
 			WeakPtr<EMEMORY_TYPE>& operator= (etk::NullPtr);
@@ -130,7 +130,7 @@ namespace ememory {
 			 */
 			bool operator==(const WeakPtr& _obj);
 			/**
-			 * @brief Check if the WeakPtr have an internal data (not nullptr)
+			 * @brief Check if the WeakPtr have an internal data (not null)
 			 * @return true The pointer is not asigned, false otherwise
 			 */
 			bool operator==(etk::NullPtr) const;
@@ -141,7 +141,7 @@ namespace ememory {
 			 */
 			bool operator!=(const WeakPtr& _obj);
 			/**
-			 * @brief Check if the SharedPtr have NOT an internal data (nullptr)
+			 * @brief Check if the SharedPtr have NOT an internal data (null)
 			 * @return true The pointer is asigned, false otherwise
 			 */
 			bool operator!=(etk::NullPtr) const;
diff --git a/ememory/details/SharedPtr.hxx b/ememory/details/SharedPtr.hxx
index f68c105..8cd7555 100644
--- a/ememory/details/SharedPtr.hxx
+++ b/ememory/details/SharedPtr.hxx
@@ -15,17 +15,17 @@ template<class EMEMORY_TYPE2,
                                  , int>::type>
 ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(EMEMORY_TYPE2* _element, deleterCall&& _deleter):
   m_element(_element),
-  m_counter(nullptr),
+  m_counter(null),
   m_deleter(_deleter) {
 	EMEMORY_DBG("Create shared");
-	if (m_element == nullptr) {
+	if (m_element == null) {
 		return;
 	}
 	EMEMORY_DBG("Check if the user use the memory allocator or personal system...");
 	ETK_MEM_CHECK_POINTER(_element);
 	EMEMORY_DBG("    ==> get previous pointer");
 	m_counter = m_element->weakFromThis().getCounter();
-	if (m_counter != nullptr) {
+	if (m_counter != null) {
 		m_counter->incrementShared();
 	}
 	return;
@@ -40,10 +40,10 @@ template<class EMEMORY_TYPE2,
                                  , int>::type>
 ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(EMEMORY_TYPE2* _element, deleterCall&& _deleter):
   m_element(_element),
-  m_counter(nullptr),
+  m_counter(null),
   m_deleter(_deleter) {
 	EMEMORY_DBG("Create shared");
-	if (m_element == nullptr) {
+	if (m_element == null) {
 		return;
 	}
 	EMEMORY_DBG("Check if the user use the memory allocator or personal system...");
@@ -53,16 +53,16 @@ ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(EMEMORY_TYPE2* _element, deleterCall
 
 template<typename EMEMORY_TYPE>
 ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr():
-  m_element(nullptr),
-  m_counter(nullptr),
+  m_element(null),
+  m_counter(null),
   m_deleter(createDeleter()) {
 	EMEMORY_DBG("Create shared");
 }
 
 template<typename EMEMORY_TYPE>
 ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(etk::NullPtr):
-  m_element(nullptr),
-  m_counter(nullptr),
+  m_element(null),
+  m_counter(null),
   m_deleter(createDeleter()) {
 	EMEMORY_DBG("Create shared");
 }
@@ -73,8 +73,8 @@ ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(EMEMORY_TYPE* _obj, ememory::Counter
   m_counter(_counter),
   m_deleter(createDeleter()) {
 	EMEMORY_DBG("Create shared (from a cast)");
-	if (_obj == nullptr) {
-		m_counter = nullptr;
+	if (_obj == null) {
+		m_counter = null;
 		return;
 	}
 	m_counter->incrementShared();
@@ -91,14 +91,14 @@ ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(const ememory::SharedPtr<EMEMORY_TYP
   m_element(_obj.m_element),
   m_counter(_obj.m_counter),
   m_deleter(_obj.m_deleter) {
-	if (    m_element == nullptr
-	     || m_counter == nullptr) {
-		m_element = nullptr;
-		m_counter = nullptr;
-		m_deleter = nullptr;
+	if (    m_element == null
+	     || m_counter == null) {
+		m_element = null;
+		m_counter = null;
+		m_deleter = null;
 		return;
 	}
-	if (m_counter == nullptr) {
+	if (m_counter == null) {
 		return;
 	}
 	m_counter->incrementShared();
@@ -110,14 +110,14 @@ ememory::SharedPtr<EMEMORY_TYPE>& ememory::SharedPtr<EMEMORY_TYPE>::operator= (c
 	m_element = _obj.m_element;
 	m_counter = _obj.m_counter;
 	m_deleter = _obj.m_deleter;
-	if (    m_element == nullptr
-	     || m_counter == nullptr) {
-		m_element = nullptr;
-		m_counter = nullptr;
-		m_deleter = nullptr;
+	if (    m_element == null
+	     || m_counter == null) {
+		m_element = null;
+		m_counter = null;
+		m_deleter = null;
 		return *this;
 	}
-	if (m_counter == nullptr) {
+	if (m_counter == null) {
 		return *this;
 	}
 	m_counter->incrementShared();
@@ -137,9 +137,9 @@ ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(ememory::SharedPtr<EMEMORY_TYPE>&& _
 	m_element = _obj.m_element;
 	m_counter = _obj.m_counter;
 	m_deleter = _obj.m_deleter;
-	_obj.m_element = nullptr;
-	_obj.m_counter = nullptr;
-	_obj.m_deleter = nullptr;
+	_obj.m_element = null;
+	_obj.m_counter = null;
+	_obj.m_deleter = null;
 }
 
 template<typename EMEMORY_TYPE>
@@ -150,13 +150,13 @@ ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(const ememory::SharedPtr<EMEMORY_TYP
   m_element(const_cast<EMEMORY_TYPE2*>(_obj.get())),
   m_counter(const_cast<ememory::Counter*>(_obj.getCounter())),
   m_deleter(createDeleter()) {
-	if (    m_element == nullptr
-	     || m_counter == nullptr) {
-		m_element = nullptr;
-		m_counter = nullptr;
+	if (    m_element == null
+	     || m_counter == null) {
+		m_element = null;
+		m_counter = null;
 		return;
 	}
-	if (m_counter == nullptr) {
+	if (m_counter == null) {
 		return;
 	}
 	m_counter->incrementShared();
@@ -171,13 +171,13 @@ ememory::SharedPtr<EMEMORY_TYPE>& ememory::SharedPtr<EMEMORY_TYPE>::operator= (c
 	m_element = const_cast<EMEMORY_TYPE2*>(_obj.get());
 	m_counter = const_cast<ememory::Counter*>(_obj.getCounter());
 	m_deleter = createDeleter();
-	if (    m_element == nullptr
-	     || m_counter == nullptr) {
-		m_element = nullptr;
-		m_counter = nullptr;
+	if (    m_element == null
+	     || m_counter == null) {
+		m_element = null;
+		m_counter = null;
 		return *this;
 	}
-	if (m_counter == nullptr) {
+	if (m_counter == null) {
 		return *this;
 	}
 	m_counter->incrementShared();
@@ -186,9 +186,9 @@ ememory::SharedPtr<EMEMORY_TYPE>& ememory::SharedPtr<EMEMORY_TYPE>::operator= (c
 
 template<typename EMEMORY_TYPE>
 void ememory::SharedPtr<EMEMORY_TYPE>::reset() {
-	if(m_counter == nullptr) {
-		m_element = nullptr; // in case ...
-		m_deleter = nullptr;
+	if(m_counter == null) {
+		m_element = null; // in case ...
+		m_deleter = null;
 		return;
 	}
 	EMEMORY_DBG("reset sharedPtr (start)");
@@ -196,8 +196,8 @@ void ememory::SharedPtr<EMEMORY_TYPE>::reset() {
 	switch(rmData) {
 		case ememory::Counter::remove::all:
 			ETK_DELETE(ememory::Counter, m_counter);
-			if (m_deleter != nullptr) {
-				if (m_element != nullptr) {
+			if (m_deleter != null) {
+				if (m_element != null) {
 					m_deleter((void*)m_element);
 				}
 			} else {
@@ -205,8 +205,8 @@ void ememory::SharedPtr<EMEMORY_TYPE>::reset() {
 			}
 			break;
 		case ememory::Counter::remove::data:
-			if (m_deleter != nullptr) {
-				if (m_element != nullptr) {
+			if (m_deleter != null) {
+				if (m_element != null) {
 					m_deleter((void*)m_element);
 				}
 			} else {
@@ -219,15 +219,15 @@ void ememory::SharedPtr<EMEMORY_TYPE>::reset() {
 		case ememory::Counter::remove::none:
 			break;
 	}
-	m_deleter = nullptr;
-	m_counter = nullptr;
-	m_element = nullptr;
+	m_deleter = null;
+	m_counter = null;
+	m_element = null;
 	EMEMORY_DBG("reset sharedPtr (stop)");
 }
 
 template<typename EMEMORY_TYPE>
 int64_t ememory::SharedPtr<EMEMORY_TYPE>::useCount() const {
-	if (m_counter == nullptr) {
+	if (m_counter == null) {
 		return 0;
 	}
 	return m_counter->getCountShared();
@@ -235,7 +235,7 @@ int64_t ememory::SharedPtr<EMEMORY_TYPE>::useCount() const {
 
 template<typename EMEMORY_TYPE>
 bool ememory::SharedPtr<EMEMORY_TYPE>::operator==(etk::NullPtr) const {
-	return m_counter == nullptr;
+	return m_counter == null;
 }
 
 template<typename EMEMORY_TYPE>
@@ -246,7 +246,7 @@ bool ememory::SharedPtr<EMEMORY_TYPE>::operator==(const SharedPtr<EMEMORY_TYPE2>
 
 template<typename EMEMORY_TYPE>
 bool ememory::SharedPtr<EMEMORY_TYPE>::operator!=(etk::NullPtr) const {
-	return m_counter != nullptr;
+	return m_counter != null;
 }
 
 template<typename EMEMORY_TYPE>
@@ -331,13 +331,13 @@ namespace ememory {
 			SharedPtr(void* _element);
 		public:
 			SharedPtr(etk::NullPtr):
-			  m_element(nullptr),
-			  m_counter(nullptr) {
+			  m_element(null),
+			  m_counter(null) {
 				EMEMORY_DBG("Create shared<void>");
 			}
 			SharedPtr():
-			  m_element(nullptr),
-			  m_counter(nullptr) {
+			  m_element(null),
+			  m_counter(null) {
 				EMEMORY_DBG("Create shared<void>");
 			}
 			~SharedPtr() {
@@ -348,8 +348,8 @@ namespace ememory {
 			  m_element(_obj),
 			  m_counter(_counter) {
 				EMEMORY_DBG("Create shared (from a cast)");
-				if (_obj == nullptr) {
-					m_counter = nullptr;
+				if (_obj == null) {
+					m_counter = null;
 					return;
 				}
 				m_counter->incrementShared();
@@ -361,20 +361,20 @@ namespace ememory {
 			SharedPtr(SharedPtr<void>&& _obj) {
 				m_element = _obj.m_element;
 				m_counter = _obj.m_counter;
-				_obj.m_element = nullptr;
-				_obj.m_counter = nullptr;
+				_obj.m_element = null;
+				_obj.m_counter = null;
 			}
 			template<class EMEMORY_TYPE2>
 			SharedPtr(const SharedPtr<EMEMORY_TYPE2>& _obj):
 			  m_element((void*)_obj.get()),
 			  m_counter(_obj.getCounter()) {
-				if (    m_element == nullptr
-				     || m_counter == nullptr) {
-					m_element = nullptr;
-					m_counter = nullptr;
+				if (    m_element == null
+				     || m_counter == null) {
+					m_element = null;
+					m_counter = null;
 					return;
 				}
-				if (m_counter == nullptr) {
+				if (m_counter == null) {
 					return;
 				}
 				m_counter->incrementShared();
@@ -384,13 +384,13 @@ namespace ememory {
 				reset();
 				m_element = (void*)_obj.get();
 				m_counter = _obj.getCounter();
-				if (    m_element == nullptr
-				     || m_counter == nullptr) {
-					m_element = nullptr;
-					m_counter = nullptr;
+				if (    m_element == null
+				     || m_counter == null) {
+					m_element = null;
+					m_counter = null;
 					return *this;
 				}
-				if (m_counter == nullptr) {
+				if (m_counter == null) {
 					return *this;
 				}
 				m_counter->incrementShared();
@@ -398,8 +398,8 @@ namespace ememory {
 			}
 		public:
 			void reset() {
-				if(m_counter == nullptr) {
-					m_element = nullptr; // in case ...
+				if(m_counter == null) {
+					m_element = null; // in case ...
 					return;
 				}
 				EMEMORY_DBG("reset sharedPtr (start)");
@@ -418,25 +418,25 @@ namespace ememory {
 					case ememory::Counter::remove::none:
 						break;
 				}
-				m_counter = nullptr;
-				m_element = nullptr;
+				m_counter = null;
+				m_element = null;
 				EMEMORY_DBG("reset sharedPtr (stop)");
 			}
 			int64_t useCount() const {
-				if (m_counter == nullptr) {
+				if (m_counter == null) {
 					return 0;
 				}
 				return m_counter->getCountShared();
 			}
 			bool operator==(etk::NullPtr) const {
-				return m_counter == nullptr;
+				return m_counter == null;
 			}
 			template<class EMEMORY_TYPE2>
 			bool operator==(const SharedPtr<EMEMORY_TYPE2>& _obj) const {
 				return m_counter == _obj.m_counter;
 			}
 			bool operator!=(etk::NullPtr) const {
-				return m_counter != nullptr;
+				return m_counter != null;
 			}
 			template<class EMEMORY_TYPE2>
 			bool operator!=(const SharedPtr<EMEMORY_TYPE2>& _obj) const {
diff --git a/ememory/details/WeakPtr.hxx b/ememory/details/WeakPtr.hxx
index ff2f77d..cb23ca5 100644
--- a/ememory/details/WeakPtr.hxx
+++ b/ememory/details/WeakPtr.hxx
@@ -11,24 +11,24 @@
 
 template<typename EMEMORY_TYPE>
 ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr():
-  m_element(nullptr),
-  m_counter(nullptr) {
+  m_element(null),
+  m_counter(null) {
 	
 }
 
 template<typename EMEMORY_TYPE>
 ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(etk::NullPtr):
-  m_element(nullptr),
-  m_counter(nullptr) {
+  m_element(null),
+  m_counter(null) {
 	
 }
 
 template<typename EMEMORY_TYPE>
 ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(EMEMORY_TYPE* _element):
   m_element(_element),
-  m_counter(nullptr) {
+  m_counter(null) {
 	EMEMORY_DBG("New weak");
-	if (m_element == nullptr) {
+	if (m_element == null) {
 		return;
 	}
 	m_counter = ETK_NEW(ememory::Counter, true);
@@ -43,13 +43,13 @@ template<typename EMEMORY_TYPE>
 ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(const ememory::WeakPtr<EMEMORY_TYPE>& _obj):
   m_element(_obj.m_element),
   m_counter(_obj.m_counter) {
-	if (    m_element == nullptr
-	     || m_counter == nullptr) {
-		m_element = nullptr;
-		m_counter = nullptr;
+	if (    m_element == null
+	     || m_counter == null) {
+		m_element = null;
+		m_counter = null;
 		return;
 	}
-	if (m_counter == nullptr) {
+	if (m_counter == null) {
 		return;
 	}
 	m_counter->incrementWeak();
@@ -60,13 +60,13 @@ ememory::WeakPtr<EMEMORY_TYPE>& ememory::WeakPtr<EMEMORY_TYPE>::operator= (const
 	reset();
 	m_element = _obj.m_element;
 	m_counter = _obj.m_counter;
-	if (    m_element == nullptr
-	     || m_counter == nullptr) {
-		m_element = nullptr;
-		m_counter = nullptr;
+	if (    m_element == null
+	     || m_counter == null) {
+		m_element = null;
+		m_counter = null;
 		return *this;
 	}
-	if (m_counter == nullptr) {
+	if (m_counter == null) {
 		return *this;
 	}
 	m_counter->incrementWeak();
@@ -83,21 +83,21 @@ template<typename EMEMORY_TYPE>
 ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(ememory::WeakPtr<EMEMORY_TYPE>&& _obj) {
 	m_element = _obj.m_element;
 	m_counter = _obj.m_counter;
-	_obj.m_element = nullptr;
-	_obj.m_counter = nullptr;
+	_obj.m_element = null;
+	_obj.m_counter = null;
 }
 
 template<typename EMEMORY_TYPE>
 ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(const ememory::SharedPtr<EMEMORY_TYPE>& _obj):
   m_element(_obj.m_element),
   m_counter(_obj.m_counter) {
-	if (    m_element == nullptr
-	     || m_counter == nullptr) {
-		m_element = nullptr;
-		m_counter = nullptr;
+	if (    m_element == null
+	     || m_counter == null) {
+		m_element = null;
+		m_counter = null;
 		return;
 	}
-	if (m_counter == nullptr) {
+	if (m_counter == null) {
 		return;
 	}
 	m_counter->incrementWeak();
@@ -109,13 +109,13 @@ ememory::WeakPtr<EMEMORY_TYPE>& ememory::WeakPtr<EMEMORY_TYPE>::operator= (const
 	reset();
 	m_element = _obj.m_element;
 	m_counter = _obj.m_counter;
-	if (    m_element == nullptr
-	     || m_counter == nullptr) {
-		m_element = nullptr;
-		m_counter = nullptr;
+	if (    m_element == null
+	     || m_counter == null) {
+		m_element = null;
+		m_counter = null;
 		return *this;
 	}
-	if (m_counter == nullptr) {
+	if (m_counter == null) {
 		return *this;
 	}
 	m_counter->incrementWeak();
@@ -131,13 +131,13 @@ template<class EMEMORY_TYPE2,
 ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(const ememory::SharedPtr<EMEMORY_TYPE2>& _obj):
   m_element((void*)_obj.get()),
   m_counter(_obj.getCounter()) {
-	if (    m_element == nullptr
-	     || m_counter == nullptr) {
-		m_element = nullptr;
-		m_counter = nullptr;
+	if (    m_element == null
+	     || m_counter == null) {
+		m_element = null;
+		m_counter = null;
 		return;
 	}
-	if (m_counter == nullptr) {
+	if (m_counter == null) {
 		return;
 	}
 	m_counter->incrementWeak();
@@ -153,13 +153,13 @@ ememory::WeakPtr<EMEMORY_TYPE>& ememory::WeakPtr<EMEMORY_TYPE>::operator= (const
 	reset();
 	m_element = (void*)_obj.get();
 	m_counter = _obj.getCounter();
-	if (    m_element == nullptr
-	     || m_counter == nullptr) {
-		m_element = nullptr;
-		m_counter = nullptr;
+	if (    m_element == null
+	     || m_counter == null) {
+		m_element = null;
+		m_counter = null;
 		return *this;
 	}
-	if (m_counter == nullptr) {
+	if (m_counter == null) {
 		return *this;
 	}
 	m_counter->incrementWeak();
@@ -174,13 +174,13 @@ template<class EMEMORY_TYPE2,
 WeakPtr(const WeakPtr<EMEMORY_TYPE2>& _obj):
   m_element(_obj.m_element),
   m_counter(_obj.getCounter()) {
-	if (    m_element == nullptr
-	     || m_counter == nullptr) {
-		m_element = nullptr;
-		m_counter = nullptr;
+	if (    m_element == null
+	     || m_counter == null) {
+		m_element = null;
+		m_counter = null;
 		return;
 	}
-	if (m_counter == nullptr) {
+	if (m_counter == null) {
 		return;
 	}
 	m_counter->incrementWeak();
@@ -193,13 +193,13 @@ WeakPtr& operator= (const WeakPtr<EMEMORY_TYPE2>& _obj) {
 	reset();
 	m_element = _obj.m_element;
 	m_counter = _obj.getCounter();
-	if (    m_element == nullptr
-	     || m_counter == nullptr) {
-		m_element = nullptr;
-		m_counter = nullptr;
+	if (    m_element == null
+	     || m_counter == null) {
+		m_element = null;
+		m_counter = null;
 		return *this;
 	}
-	if (m_counter == nullptr) {
+	if (m_counter == null) {
 		return *this;
 	}
 	m_counter->incrementWeak();
@@ -208,8 +208,8 @@ WeakPtr& operator= (const WeakPtr<EMEMORY_TYPE2>& _obj) {
 */
 template<typename EMEMORY_TYPE>
 void ememory::WeakPtr<EMEMORY_TYPE>::reset() {
-	if(m_counter == nullptr) {
-		m_element = nullptr; // in case ...
+	if(m_counter == null) {
+		m_element = null; // in case ...
 		return;
 	}
 	ememory::Counter::remove rmData = m_counter->decrementWeak();
@@ -226,13 +226,13 @@ void ememory::WeakPtr<EMEMORY_TYPE>::reset() {
 		case ememory::Counter::remove::none:
 			break;
 	}
-	m_counter = nullptr;
-	m_element = nullptr;
+	m_counter = null;
+	m_element = null;
 }
 
 template<typename EMEMORY_TYPE>
 int ememory::WeakPtr<EMEMORY_TYPE>::useCount() const {
-	if (m_counter == nullptr) {
+	if (m_counter == null) {
 		return 0;
 	}
 	return m_counter->getCountShared();
@@ -240,7 +240,7 @@ int ememory::WeakPtr<EMEMORY_TYPE>::useCount() const {
 
 template<typename EMEMORY_TYPE>
 bool ememory::WeakPtr<EMEMORY_TYPE>::expired() const {
-	if (m_counter == nullptr) {
+	if (m_counter == null) {
 		return true;
 	}
 	return m_counter->getCountShared() == 0;
@@ -249,7 +249,7 @@ bool ememory::WeakPtr<EMEMORY_TYPE>::expired() const {
 template<typename EMEMORY_TYPE>
 ememory::SharedPtr<EMEMORY_TYPE> ememory::WeakPtr<EMEMORY_TYPE>::lock() {
 	ememory::SharedPtr<EMEMORY_TYPE> out;
-	if (m_counter == nullptr) {
+	if (m_counter == null) {
 		return out;
 	}
 	int64_t count = m_counter->incrementShared(true);
@@ -268,7 +268,7 @@ bool ememory::WeakPtr<EMEMORY_TYPE>::operator==(const ememory::WeakPtr<EMEMORY_T
 
 template<typename EMEMORY_TYPE>
 bool ememory::WeakPtr<EMEMORY_TYPE>::operator==(etk::NullPtr) const {
-	return m_counter == nullptr;
+	return m_counter == null;
 }
 
 template<typename EMEMORY_TYPE>
@@ -278,7 +278,7 @@ bool ememory::WeakPtr<EMEMORY_TYPE>::operator!=(const ememory::WeakPtr<EMEMORY_T
 
 template<typename EMEMORY_TYPE>
 bool ememory::WeakPtr<EMEMORY_TYPE>::operator!=(etk::NullPtr) const {
-	return m_counter != nullptr;
+	return m_counter != null;
 }
 
 template<typename EMEMORY_TYPE>
diff --git a/test/testShared.cpp b/test/testShared.cpp
index 8942020..ecfe383 100644
--- a/test/testShared.cpp
+++ b/test/testShared.cpp
@@ -14,36 +14,36 @@ TEST(TestShared, createAndDestroy) {
 	ememory::SharedPtr<etk::String> data = ememory::makeShared<etk::String>("coucou");
 	EXPECT_EQ(data.useCount(), 1);
 	EXPECT_EQ(*data, "coucou");
-	EXPECT_EQ(data == nullptr, false);
-	EXPECT_EQ(data != nullptr, true);
+	EXPECT_EQ(data == null, false);
+	EXPECT_EQ(data != null, true);
 	data.reset();
 	EXPECT_EQ(data.useCount(), 0);
-	EXPECT_EQ(data == nullptr, true);
-	EXPECT_EQ(data != nullptr, false);
+	EXPECT_EQ(data == null, true);
+	EXPECT_EQ(data != null, false);
 }
 
 TEST(TestShared, createAndDestroy_2) {
 	ememory::SharedPtr<etk::String> data = ememory::SharedPtr<etk::String>(ETK_NEW(etk::String, "coucou"));
 	EXPECT_EQ(data.useCount(), 1);
 	EXPECT_EQ(*data, "coucou");
-	EXPECT_EQ(data == nullptr, false);
-	EXPECT_EQ(data != nullptr, true);
+	EXPECT_EQ(data == null, false);
+	EXPECT_EQ(data != null, true);
 	data.reset();
 	EXPECT_EQ(data.useCount(), 0);
-	EXPECT_EQ(data == nullptr, true);
-	EXPECT_EQ(data != nullptr, false);
+	EXPECT_EQ(data == null, true);
+	EXPECT_EQ(data != null, false);
 }
 
 TEST(TestShared, createAndDestroy_3) {
 	ememory::SharedPtr<etk::String> data = ememory::SharedPtr<etk::String>(new etk::String("coucou"));
 	EXPECT_EQ(data.useCount(), 1);
 	EXPECT_EQ(*data, "coucou");
-	EXPECT_EQ(data == nullptr, false);
-	EXPECT_EQ(data != nullptr, true);
+	EXPECT_EQ(data == null, false);
+	EXPECT_EQ(data != null, true);
 	data.reset();
 	EXPECT_EQ(data.useCount(), 0);
-	EXPECT_EQ(data == nullptr, true);
-	EXPECT_EQ(data != nullptr, false);
+	EXPECT_EQ(data == null, true);
+	EXPECT_EQ(data != null, false);
 }
 
 TEST(TestShared, copy) {
@@ -119,9 +119,9 @@ TEST(TestShared, heritage) {
 	ememory::SharedPtr<heritedClass> data = ememory::makeShared<heritedClass>();
 	ememory::SharedPtr<basicClass> data2 = data;
 	ememory::SharedPtr<basicClass> data3(data);
-	EXPECT_NE(data, nullptr);
-	EXPECT_NE(data2, nullptr);
-	EXPECT_NE(data3, nullptr);
+	EXPECT_NE(data, null);
+	EXPECT_NE(data2, null);
+	EXPECT_NE(data3, null);
 }
 
 
diff --git a/test/testUnique.cpp b/test/testUnique.cpp
index 9cf1222..d48be0e 100644
--- a/test/testUnique.cpp
+++ b/test/testUnique.cpp
@@ -13,22 +13,22 @@
 
 TEST(TestEmemoryUniquePtr, Creation_1) {
 	ememory::UniquePtr<uint32_t> testData;
-	EXPECT_EQ(testData.get(), nullptr);
+	EXPECT_EQ(testData.get(), null);
 }
 
 TEST(TestEmemoryUniquePtr, Creation_2) {
 	ememory::UniquePtr<uint32_t> testData(new uint32_t(55));
-	EXPECT_NE(testData.get(), nullptr);
+	EXPECT_NE(testData.get(), null);
 	EXPECT_EQ(*testData.get(), 55);
 }
 TEST(TestEmemoryUniquePtr, Creation_3) {
 	ememory::UniquePtr<uint32_t> testData(ETK_NEW(uint32_t, 55));
-	EXPECT_NE(testData.get(), nullptr);
+	EXPECT_NE(testData.get(), null);
 	EXPECT_EQ(*testData.get(), 55);
 }
 TEST(TestEmemoryUniquePtr, Creation_4) {
 	ememory::UniquePtr<uint32_t> testData = ememory::makeUniquePtr<uint32_t>(456789);
-	EXPECT_NE(testData.get(), nullptr);
+	EXPECT_NE(testData.get(), null);
 	EXPECT_EQ(*testData.get(), 456789);
 }
 
@@ -51,26 +51,26 @@ TEST(TestEmemoryUniquePtr, reset) {
 	memset(vals, 0, sizeof(vals));
 	EXPECT_EQ(vals[1], 0);
 	ememory::UniquePtr<testCreateAndDestroy> testData = ememory::makeUniquePtr<testCreateAndDestroy>(1);
-	EXPECT_NE(testData.get(), nullptr);
+	EXPECT_NE(testData.get(), null);
 	EXPECT_EQ(vals[1], 1);
 	testData.reset();
-	EXPECT_EQ(testData.get(), nullptr);
+	EXPECT_EQ(testData.get(), null);
 	EXPECT_EQ(vals[1], -1);
 }
 TEST(TestEmemoryUniquePtr, reset_2) {
 	memset(vals, 0, sizeof(vals));
 	EXPECT_EQ(vals[1], 0);
 	ememory::UniquePtr<testCreateAndDestroy> testData = ememory::makeUniquePtr<testCreateAndDestroy>(1);
-	EXPECT_NE(testData.get(), nullptr);
+	EXPECT_NE(testData.get(), null);
 	EXPECT_EQ(vals[1], 1);
-	testData = nullptr;
-	EXPECT_EQ(testData.get(), nullptr);
+	testData = null;
+	EXPECT_EQ(testData.get(), null);
 	EXPECT_EQ(vals[1], -1);
 }
 TEST(TestEmemoryUniquePtr, overwrite) {
 	memset(vals, 0, sizeof(vals));
 	ememory::UniquePtr<testCreateAndDestroy> testData = ememory::makeUniquePtr<testCreateAndDestroy>(1);
-	EXPECT_NE(testData.get(), nullptr);
+	EXPECT_NE(testData.get(), null);
 	EXPECT_EQ(vals[1], 1);
 	EXPECT_EQ(vals[2], 0);
 	testData = ememory::makeUniquePtr<testCreateAndDestroy>(2);
diff --git a/test/testWeak.cpp b/test/testWeak.cpp
index c9cebb1..105931a 100644
--- a/test/testWeak.cpp
+++ b/test/testWeak.cpp
@@ -37,7 +37,7 @@ TEST(TestWeak, retrive) {
 	EXPECT_EQ(dataRetrive.useCount(), 0);
 	EXPECT_EQ(dataWeak.useCount(), 0);
 	dataRetrive = dataWeak.lock();
-	EXPECT_EQ(dataRetrive == nullptr, true);
+	EXPECT_EQ(dataRetrive == null, true);
 	EXPECT_EQ(dataRetrive.useCount(), 0);
 	EXPECT_EQ(dataWeak.useCount(), 0);
 }