diff --git a/src/liboncilla/Oncilla.h b/src/liboncilla/Oncilla.h
index e406862..2127982 100644
--- a/src/liboncilla/Oncilla.h
+++ b/src/liboncilla/Oncilla.h
@@ -1,98 +1,98 @@
 /*
  * Oncilla.h
  *
  *  Created on: 15 dec. 2011
  *      Author: Alexandre Tuleu, Arne Nordmann
  */
 #pragma once
 
 #include <vector>
 #include <iostream>
 #include <boost/shared_ptr.hpp>
 
 #include "common.h"
 #include "Supervisor.h"
 #include <liboncilla/utils/OncillaBackend.h>
 #include <liboncilla/Synchronizer.h>
 #include <liboncilla/nodes/Nodes.h>
 #include <set>
 
 
 namespace rci {
 namespace oncilla {
 
 class BackendLoader;
 
 
 class Oncilla {
 public:
 	typedef boost::shared_ptr<Oncilla>  Ptr;
 	/**
 	 * When an Oncilla object is created, it will initialize all the resources
 	 * corresponding to node regarding the backend. At the backend level, if
 	 * some error happens, it will results by an Exception beeing thrown, for
 	 * example if one of the motor device is not available. User can change the
 	 * behavior by masking this exception, and defer them to the point where
 	 * they actually use the non-initialized node. This allow a finer control
 	 * of the robot, if an user want to drive only a leg and does not care if the
 	 * rest of the robot is online. By default throwing on initialization is
 	 * enabled.
 	 * @param throwOn if \true, Oncilla object will throw exception on initialization.
 	 */
 	static void throwExceptionOnInitialization(bool throwOn);
 	static bool willThrowOnInitialization();
 
 	static std::string nameOfLeg(Leg l);
 
 	Oncilla();
 	Oncilla(const OncillaBackend::Ptr & backend);
 	virtual ~Oncilla();
 
 	const L0::Ptr & getL0(Leg l) const;
 	const L1::Ptr & getL1(Leg l) const;
 	const L2::Ptr & getL2(Leg l) const;
 	const L3::Ptr & getL3(Leg l) const;
 	const Trunk::Ptr & getTrunk() const;
 
 	const rci::oncilla::Synchronizer::Ptr  & getSynchronizer() const;
 
 	const rci::oncilla::Supervisor::Ptr & getSupervisor() const;
 
 private :
 	typedef std::vector<std::string> LegNames;
 	typedef std::set<OncillaBackend::Ptr>  SetOfBackend;
-	typedef std::tr1::shared_ptr<std::runtime_error> RuntimeErrPtr;
+	typedef std::shared_ptr<std::runtime_error> RuntimeErrPtr;
 	typedef std::vector<RuntimeErrPtr> ListOfErrors;
 
 	void init();
 
 	static SetOfBackend        s_backends;
 	static bool s_throwExceptionOnInitialization;
 
 
 	rci::oncilla::Synchronizer::Ptr d_synchronizer;
 
 	//object cerated with teh backend depend on the backen existance, so this
 	// pointer should be first (even if we save the backends in the static set)
 	OncillaBackend::Ptr d_backend;
 
 
 	std::vector<L0::Ptr> d_L0s;
 	std::vector<L1::Ptr> d_L1s;
 	std::vector<L2::Ptr> d_L2s;
 	std::vector<L3::Ptr> d_L3s;
 
 	ListOfErrors d_L0Errors;
 	ListOfErrors d_L1Errors;
 	ListOfErrors d_L2Errors;
 	ListOfErrors d_L3Errors;
 
 	Trunk::Ptr d_trunk;
 	RuntimeErrPtr d_trunkError;
 
 
 	Supervisor::Ptr d_supervisor;
 };
 
 }
 }
diff --git a/src/liboncilla/Supervisor.h b/src/liboncilla/Supervisor.h
index a6c1dc9..adb7734 100644
--- a/src/liboncilla/Supervisor.h
+++ b/src/liboncilla/Supervisor.h
@@ -1,48 +1,48 @@
 /*
  * Supervisor.h
  *
  *  Created on: Jan 21, 2013
  *      Author: tuleu
  */
 
 #ifndef SUPERVISOR_H_
 #define SUPERVISOR_H_
 
 #include <liboncilla/nodes/SupervisorNodes.h>
 #include "common.h"
 
-#include <tr1/memory>
+#include <memory>
 #include <vector>
 
 class OncillaBackend;
 
 namespace rci {
 namespace oncilla {
 
 class Supervisor {
 public:
 	typedef boost::shared_ptr<rci::oncilla::Supervisor> Ptr;
 	Supervisor(OncillaBackend & backend);
 	virtual ~Supervisor();
 
 	const SupervisorTrunk::Ptr & getTrunk();
 
 	const SupervisorL4::Ptr & getL4(Leg l);
 
 	const SupervisorWorld::Ptr & getWorld();
 private:
-	typedef std::tr1::shared_ptr<std::runtime_error> RuntimeErrPtr;
+	typedef std::shared_ptr<std::runtime_error> RuntimeErrPtr;
 	typedef std::vector<RuntimeErrPtr> ListOfError;
 
 	std::vector<SupervisorL4::Ptr> d_l4s;
 	ListOfError d_l4Errors;
 	SupervisorTrunk::Ptr d_trunk;
 	RuntimeErrPtr d_trunkError;
 	SupervisorWorld::Ptr d_world;
 	RuntimeErrPtr d_worldError;
 
 };
 
 } /* namespace oncilla */
 } /* namespace rci */
 #endif /* SUPERVISOR_H_ */
diff --git a/src/liboncilla/utils/OncillaBackend.h b/src/liboncilla/utils/OncillaBackend.h
index 044a390..26d227d 100644
--- a/src/liboncilla/utils/OncillaBackend.h
+++ b/src/liboncilla/utils/OncillaBackend.h
@@ -1,63 +1,63 @@
 /*
  * Backend.h
  *
  *  Created on: Jan 18, 2013
  *      Author: tuleu
  */
 
 #ifndef LIBONCILLA_ONCILLABACKEND_H_
 #define LIBONCILLA_ONCILLABACKEND_H_
 
 #include <biorob-cpp/plugin/PluginLoader.h>
 #include <biorob-cpp/base/common.h>
 #include <boost/shared_ptr.hpp>
 #include <liboncilla/common.h>
 
 namespace rci {
 namespace oncilla {
 
 	class Synchronizer;
 	class L0;
 	class L1L2;
 	class L3;
 	typedef L1L2 L1;
 	typedef L1L2 L2;
 	class Trunk;
 	class SupervisorWorld;
 	class SupervisorTrunk;
 	class SupervisorL4;
 
 } /* namespace oncilla */
 } /* namespace rci */
 
 class OncillaBackend {
 	BIOROB_CPP_DECLARE_PLUGIN (OncillaBackend);
 	DISABLE_ASSIGNEMENT (OncillaBackend);
 	DISABLE_COPY (OncillaBackend);
 public:
-	typedef std::tr1::shared_ptr<OncillaBackend> Ptr;
+	typedef std::shared_ptr<OncillaBackend> Ptr;
 	OncillaBackend();
 	virtual ~OncillaBackend();
 	virtual boost::shared_ptr<rci::oncilla::Synchronizer> CreateSynchronizer() = 0;
 
 	virtual boost::shared_ptr<rci::oncilla::L0> CreateL0(rci::oncilla::Leg l,
 	                                                     const std::string & name) = 0;
 	virtual boost::shared_ptr<rci::oncilla::L1> CreateL1(rci::oncilla::Leg l,
 	                                                     const std::string & name) = 0;
 	virtual boost::shared_ptr<rci::oncilla::L2> CreateL2(rci::oncilla::Leg l,
 	                                                     const std::string & name) = 0;
 	virtual boost::shared_ptr<rci::oncilla::L3> CreateL3(rci::oncilla::Leg l,
 	                                                     const std::string & name) = 0;
 
 	virtual boost::shared_ptr<rci::oncilla::Trunk> CreateTrunk() = 0;
 
 	virtual boost::shared_ptr<rci::oncilla::SupervisorWorld> CreateSupervisorWorld() = 0;
 
 	virtual boost::shared_ptr<rci::oncilla::SupervisorTrunk> CreateSupervisorTrunk() = 0;
 
 	virtual boost::shared_ptr<rci::oncilla::SupervisorL4> CreateSupervisorL4(rci::oncilla::Leg l,
 	                                                                         const std::string & name) = 0;
 
 };
 
 #endif /* LIBONCILLA_ONCILLABACKEND_H_ */