diff --git a/CMakeLists.txt b/CMakeLists.txt
index b406f58..e868dd0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -15,6 +15,7 @@ set(PACKAGE_VERSION 1.6.1)
 option(LIBCREATE_BUILD_TESTS "Enable the build of tests." ON)
 
 find_package(Boost REQUIRED COMPONENTS system thread)
+find_package(serial REQUIRED)
 find_package(Threads REQUIRED)
 
 # Default to C++11
@@ -31,6 +32,7 @@ set(LIBRARY_NAME create)
 # Specify locations of header files
 include_directories(
   include
+  ${serial_INCLUDE_DIRS}
 )
 
 # Declare cpp library
@@ -56,6 +58,7 @@ endif()
 
 # Link to Boost
 target_link_libraries(${LIBRARY_NAME}
+  ${serial_LIBRARIES}
   ${Boost_LIBRARIES}
 )
 
@@ -75,6 +78,7 @@ foreach(EXAMPLE ${EXAMPLES})
   add_executable(${EXAMPLE} examples/${EXAMPLE}.cpp)
 
   target_link_libraries(${EXAMPLE}
+    ${serial_LIBRARIES}
     ${Boost_LIBRARIES}
     ${LIBRARY_NAME}
   )
diff --git a/include/create/create.h b/include/create/create.h
index 14ede01..6ca2fe9 100644
--- a/include/create/create.h
+++ b/include/create/create.h
@@ -32,9 +32,9 @@ POSSIBILITY OF SUCH DAMAGE.
 #ifndef CREATE_H
 #define CREATE_H
 
-#include <boost/shared_ptr.hpp>
 #include <boost/numeric/ublas/matrix.hpp>
 #include <chrono>
+#include <memory>
 #include <string>
 #include <unistd.h>
 
@@ -96,8 +96,8 @@ namespace create {
       bool updateLEDs();
 
     protected:
-      boost::shared_ptr<create::Data> data;
-      boost::shared_ptr<create::Serial> serial;
+      std::shared_ptr<create::Data> data;
+      std::shared_ptr<create::Serial> serial;
 
     public:
       /**
diff --git a/include/create/data.h b/include/create/data.h
index 345bd1a..c4392e8 100644
--- a/include/create/data.h
+++ b/include/create/data.h
@@ -32,9 +32,8 @@ POSSIBILITY OF SUCH DAMAGE.
 #ifndef CREATE_DATA_H
 #define CREATE_DATA_H
 
-#include <boost/shared_ptr.hpp>
-#include <boost/make_shared.hpp>
 #include <map>
+#include <memory>
 #include <vector>
 
 #include "create/packet.h"
@@ -43,7 +42,7 @@ POSSIBILITY OF SUCH DAMAGE.
 namespace create {
   class Data {
     private:
-      std::map<uint8_t, boost::shared_ptr<Packet> > packets;
+      std::map<uint8_t, std::shared_ptr<Packet> > packets;
       uint32_t totalDataBytes;
       std::vector<uint8_t> ids;
 
@@ -52,7 +51,7 @@ namespace create {
       ~Data();
 
       bool isValidPacketID(const uint8_t id) const;
-      boost::shared_ptr<Packet> getPacket(const uint8_t id);
+      std::shared_ptr<Packet> getPacket(const uint8_t id);
       void validateAll();
       uint32_t getTotalDataBytes() const;
       uint8_t getNumPackets() const;
diff --git a/include/create/packet.h b/include/create/packet.h
index da0a6e2..d1e7928 100644
--- a/include/create/packet.h
+++ b/include/create/packet.h
@@ -31,15 +31,15 @@ POSSIBILITY OF SUCH DAMAGE.
 #ifndef CREATE_PACKET_H
 #define CREATE_PACKET_H
 
-#include <boost/thread/mutex.hpp>
+#include <mutex>
 
 namespace create {
   class Packet {
     private:
       uint16_t data;
       uint16_t tmpData;
-      mutable boost::mutex dataMutex;
-      mutable boost::mutex tmpDataMutex;
+      mutable std::mutex dataMutex;
+      mutable std::mutex tmpDataMutex;
 
     protected:
       // Thread safe
diff --git a/include/create/serial.h b/include/create/serial.h
index 6ae9eba..56e4740 100644
--- a/include/create/serial.h
+++ b/include/create/serial.h
@@ -29,50 +29,46 @@ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 */
 
-// Based on example from:
-//   https://github.com/labust/labust-ros-pkg/wiki/Create-a-Serial-Port-application
-
 #ifndef CREATE_SERIAL_H
 #define CREATE_SERIAL_H
 
-#include <boost/asio.hpp>
-#include <boost/thread.hpp>
-#include <boost/thread/condition_variable.hpp>
-#include <boost/function.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/enable_shared_from_this.hpp>
+#include <condition_variable>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <thread>
+
+#include <serial/serial.h>
 
 #include "create/data.h"
 #include "create/types.h"
 #include "create/util.h"
 
 namespace create {
-  class Serial : public boost::enable_shared_from_this<Serial> {
+  class Serial : public std::enable_shared_from_this<Serial> {
 
     protected:
-      boost::asio::io_service io;
-      boost::asio::signal_set signals;
-      boost::asio::serial_port port;
+      serial::Serial serial;
 
     private:
-      boost::thread ioThread;
-      boost::condition_variable dataReadyCond;
-      boost::mutex dataReadyMut;
+      std::thread ioThread;
+      std::condition_variable dataReadyCond;
+      std::mutex dataReadyMut;
       bool dataReady;
       bool isReading;
       bool firstRead;
       uint8_t byteRead;
 
       // Callback executed when data arrives from Create
-      void onData(const boost::system::error_code& e, const std::size_t& size);
+      void onData();
       // Callback to execute once data arrives
-      boost::function<void()> callback;
+      std::function<void()> callback;
       // Start and stop reading data from Create
       bool startReading();
       void stopReading();
 
     protected:
-      boost::shared_ptr<Data> data;
+      std::shared_ptr<Data> data;
       // These are for possible diagnostics
       uint64_t corruptPackets;
       uint64_t totalPackets;
@@ -80,16 +76,18 @@ namespace create {
       virtual bool startSensorStream() = 0;
       virtual void processByte(uint8_t byteRead) = 0;
 
-      void signalHandler(const boost::system::error_code& error, int signal_number);
+      // TODO
+      // void signalHandler(const boost::system::error_code& error, int signal_number);
+
       // Notifies main thread that data is fresh and makes the user callback
       void notifyDataReady();
 
     public:
-      Serial(boost::shared_ptr<Data> data);
+      Serial(std::shared_ptr<Data> data);
       ~Serial();
-      bool connect(const std::string& port, const int& baud = 115200, boost::function<void()> cb = 0);
+      bool connect(const std::string& port, const int& baud = 115200, std::function<void()> cb = 0);
       void disconnect();
-      inline bool connected() const { return port.is_open(); };
+      inline bool connected() const { return serial.isOpen(); };
       bool send(const uint8_t* bytes, const uint32_t numBytes);
       bool sendOpcode(const Opcode& code);
       uint64_t getNumCorruptPackets() const;
diff --git a/include/create/serial_query.h b/include/create/serial_query.h
index 033785a..a11e3f8 100644
--- a/include/create/serial_query.h
+++ b/include/create/serial_query.h
@@ -36,11 +36,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #ifndef CREATE_SERIAL_QUERY_H
 #define CREATE_SERIAL_QUERY_H
 
-#include <boost/asio.hpp>
-#include <boost/thread.hpp>
-#include <boost/thread/condition_variable.hpp>
-#include <boost/function.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 #include "create/data.h"
 #include "create/types.h"
@@ -51,7 +47,7 @@ namespace create {
   class SerialQuery : public Serial {
 
     private:
-      boost::asio::deadline_timer streamRecoveryTimer;
+      // boost::asio::deadline_timer streamRecoveryTimer;
       uint8_t packetID;
       int8_t packetByte;
       uint16_t packetData;
@@ -60,7 +56,7 @@ namespace create {
       bool started;
 
       void requestSensorData();
-      void restartSensorStream(const boost::system::error_code& err);
+      // void restartSensorStream(const boost::system::error_code& err);
 
       void flushInput();
 
@@ -69,7 +65,7 @@ namespace create {
       void processByte(uint8_t byteRead);
 
     public:
-      SerialQuery(boost::shared_ptr<Data> data);
+      SerialQuery(std::shared_ptr<Data> data);
   };
 }  // namespace create
 
diff --git a/include/create/serial_stream.h b/include/create/serial_stream.h
index d59d126..07d4c05 100644
--- a/include/create/serial_stream.h
+++ b/include/create/serial_stream.h
@@ -35,11 +35,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #ifndef CREATE_SERIAL_STREAM_H
 #define CREATE_SERIAL_STREAM_H
 
-#include <boost/asio.hpp>
-#include <boost/thread.hpp>
-#include <boost/thread/condition_variable.hpp>
-#include <boost/function.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 #include "create/data.h"
 #include "create/types.h"
@@ -73,7 +69,7 @@ namespace create {
       void processByte(uint8_t byteRead);
 
     public:
-      SerialStream(boost::shared_ptr<Data> data, const uint8_t& header = create::util::STREAM_HEADER);
+      SerialStream(std::shared_ptr<Data> data, const uint8_t& header = create::util::STREAM_HEADER);
 
   };
 }  // namespace create
diff --git a/package.xml b/package.xml
index aa633ad..ef8a8c8 100644
--- a/package.xml
+++ b/package.xml
@@ -16,7 +16,7 @@
 
   <buildtool_depend>cmake</buildtool_depend>
 
-  <depend>boost</depend>
+  <depend>serial</depend>
 
   <exec_depend condition="$ROS_VERSION == 1">catkin</exec_depend>
 
diff --git a/src/create.cpp b/src/create.cpp
index a0f9da6..35d7f39 100644
--- a/src/create.cpp
+++ b/src/create.cpp
@@ -1,8 +1,7 @@
-#include <boost/bind.hpp>
-#include <boost/make_shared.hpp>
 #include <iostream>
 #include <cmath>
 #include <ctime>
+#include <memory>
 #include <assert.h>
 
 #include "create/create.h"
@@ -42,11 +41,11 @@ namespace create {
     poseCovar = Matrix(3, 3, 0.0);
     requestedLeftVel = 0;
     requestedRightVel = 0;
-    data = boost::shared_ptr<Data>(new Data(model.getVersion()));
+    data = std::shared_ptr<Data>(new Data(model.getVersion()));
     if (model.getVersion() == V_1) {
-      serial = boost::make_shared<SerialQuery>(data);
+      serial = std::make_shared<SerialQuery>(data);
     } else {
-      serial = boost::make_shared<SerialStream>(data);
+      serial = std::make_shared<SerialStream>(data);
     }
   }
 
@@ -273,7 +272,7 @@ namespace create {
     float maxWait = 30; // seconds
     float retryInterval = 5; //seconds
     time(&start);
-    while (!serial->connect(port, baud, boost::bind(&Create::onData, this)) && !timeout) {
+    while (!serial->connect(port, baud, std::bind(&Create::onData, this)) && !timeout) {
       time(&now);
       if (difftime(now, start) > maxWait) {
         timeout = true;
diff --git a/src/data.cpp b/src/data.cpp
index f8eab92..3bc7f38 100644
--- a/src/data.cpp
+++ b/src/data.cpp
@@ -1,6 +1,6 @@
 #include "create/data.h"
 
-#define ADD_PACKET(id,nbytes,info,enabledVersion) if ((enabledVersion) & version) packets[id]=boost::make_shared<Packet>(nbytes,info)
+#define ADD_PACKET(id,nbytes,info,enabledVersion) if ((enabledVersion) & version) packets[id]=std::make_shared<Packet>(nbytes,info)
 
 namespace create {
 
@@ -45,7 +45,7 @@ namespace create {
     ADD_PACKET(ID_STASIS, 1, "stasis", V_3);
 
     totalDataBytes = 0;
-    for (std::map<uint8_t, boost::shared_ptr<Packet> >::iterator it = packets.begin();
+    for (std::map<uint8_t, std::shared_ptr<Packet> >::iterator it = packets.begin();
          it != packets.end();
          ++it) {
       ids.push_back(it->first);
@@ -62,15 +62,15 @@ namespace create {
     return false;
   }
 
-  boost::shared_ptr<Packet> Data::getPacket(uint8_t id) {
+  std::shared_ptr<Packet> Data::getPacket(uint8_t id) {
     if (isValidPacketID(id)) {
       return packets[id];
     }
-    return boost::shared_ptr<Packet>();
+    return std::shared_ptr<Packet>();
   }
 
   void Data::validateAll() {
-    for (std::map<uint8_t, boost::shared_ptr<Packet> >::iterator it = packets.begin();
+    for (std::map<uint8_t, std::shared_ptr<Packet> >::iterator it = packets.begin();
          it != packets.end();
          ++it) {
       it->second->validate();
diff --git a/src/packet.cpp b/src/packet.cpp
index d408f75..517e90d 100644
--- a/src/packet.cpp
+++ b/src/packet.cpp
@@ -1,3 +1,5 @@
+#include <memory>
+
 #include "create/packet.h"
 
 namespace create {
@@ -11,22 +13,22 @@ namespace create {
   Packet::~Packet() { }
 
   void Packet::setDataToValidate(const uint16_t& tmp) {
-    boost::mutex::scoped_lock lock(tmpDataMutex);
+    std::lock_guard<std::mutex> lock(tmpDataMutex);
     tmpData = tmp;
   }
 
   void Packet::validate() {
-    boost::mutex::scoped_lock lock(tmpDataMutex);
+    std::lock_guard<std::mutex> lock(tmpDataMutex);
     setData(tmpData);
   }
 
   void Packet::setData(const uint16_t& d) {
-    boost::mutex::scoped_lock lock(dataMutex);
+    std::lock_guard<std::mutex> lock(dataMutex);
     data = d;
   }
 
   uint16_t Packet::getData() const {
-    boost::mutex::scoped_lock lock(dataMutex);
+    std::lock_guard<std::mutex> lock(dataMutex);
     return data;
   }
 
diff --git a/src/serial.cpp b/src/serial.cpp
index ad9f7fc..562c19b 100644
--- a/src/serial.cpp
+++ b/src/serial.cpp
@@ -1,13 +1,17 @@
+#include <chrono>
+#include <functional>
 #include <iostream>
+#include <thread>
+
+#include <serial/serial.h>
 
 #include "create/serial.h"
 #include "create/types.h"
 
 namespace create {
 
-  Serial::Serial(boost::shared_ptr<Data> d) :
-    signals(io, SIGINT, SIGTERM),
-    port(io),
+  Serial::Serial(std::shared_ptr<Data> d) :
+    serial(),
     dataReady(false),
     isReading(false),
     data(d),
@@ -19,36 +23,35 @@ namespace create {
     disconnect();
   }
 
-  void Serial::signalHandler(const boost::system::error_code& error, int signal_number) {
-    if (!error) {
-      if (connected()) {
-        // Ensure not in Safe/Full modes
-        sendOpcode(OC_START);
-        // Stop OI
-        sendOpcode(OC_STOP);
-        exit(signal_number);
-      }
-    }
-  }
-
-  bool Serial::connect(const std::string& portName, const int& baud, boost::function<void()> cb) {
-    using namespace boost::asio;
-    port.open(portName);
-    port.set_option(serial_port::baud_rate(baud));
-    port.set_option(serial_port::character_size(8));
-    port.set_option(serial_port::parity(serial_port::parity::none));
-    port.set_option(serial_port::stop_bits(serial_port::stop_bits::one));
-    port.set_option(serial_port::flow_control(serial_port::flow_control::none));
-
-    signals.async_wait(boost::bind(&Serial::signalHandler, this, _1, _2));
-
-    usleep(1000000);
-
-    if (port.is_open()) {
+  // TODO
+  // void Serial::signalHandler(const boost::system::error_code& error, int signal_number) {
+  //   if (!error) {
+  //     if (connected()) {
+  //       // Ensure not in Safe/Full modes
+  //       sendOpcode(OC_START);
+  //       // Stop OI
+  //       sendOpcode(OC_STOP);
+  //       exit(signal_number);
+  //     }
+  //   }
+  // }
+
+  bool Serial::connect(const std::string& portName, const int& baud, std::function<void()> cb) {
+    // using namespace boost::asio;
+    serial.setPort(portName);
+    serial.setBaudrate(baud);
+    serial.open();
+
+    // TODO
+    // signals.async_wait(std::bind(&Serial::signalHandler, this, std::placeholders::_1, std::placeholders::_2));
+
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+
+    if (serial.isOpen()) {
       callback = cb;
       bool startReadSuccess = startReading();
       if (!startReadSuccess) {
-        port.close();
+        serial.close();
       }
       return startReadSuccess;
     }
@@ -65,7 +68,7 @@ namespace create {
       sendOpcode(OC_START);
       // Stop OI
       sendOpcode(OC_STOP);
-      port.close();
+      serial.close();
     }
   }
 
@@ -85,25 +88,20 @@ namespace create {
 
     if (!startSensorStream()) return false;
 
-    io.reset();
-
     // Start continuously reading one byte at a time
-    boost::asio::async_read(port,
-                            boost::asio::buffer(&byteRead, 1),
-                            boost::bind(&Serial::onData, shared_from_this(), _1, _2));
-
-    ioThread = boost::thread(boost::bind(&boost::asio::io_service::run, &io));
+    ioThread = std::thread(std::bind(&Serial::onData, this));
 
     // Wait for first complete read to finish
-    boost::unique_lock<boost::mutex> lock(dataReadyMut);
+    // TODO: remove this mutex and use atomic variable?
+    std::unique_lock<std::mutex> lock(dataReadyMut);
 
     int attempts = 1;
     int maxAttempts = 10;
     while (!dataReady) {
-      if (!dataReadyCond.timed_wait(lock, boost::get_system_time() + boost::posix_time::milliseconds(500))) {
+      if (dataReadyCond.wait_for(lock, std::chrono::milliseconds(500)) == std::cv_status::timeout) {
         if (attempts >= maxAttempts) {
           CERR("[create::Serial] ", "failed to receive data from Create. Check if robot is powered!");
-          io.stop();
+          serial.close();
           ioThread.join();
           return false;
         }
@@ -121,11 +119,11 @@ namespace create {
 
   void Serial::stopReading() {
     if (isReading) {
-      io.stop();
+      serial.close();
       ioThread.join();
       isReading = false;
       {
-        boost::lock_guard<boost::mutex> lock(dataReadyMut);
+        std::lock_guard<std::mutex> lock(dataReadyMut);
         dataReady = false;
       }
     }
@@ -138,7 +136,7 @@ namespace create {
 
     // Notify first data packets ready
     {
-      boost::lock_guard<boost::mutex> lock(dataReadyMut);
+      std::lock_guard<std::mutex> lock(dataReadyMut);
       if (!dataReady) {
         dataReady = true;
         dataReadyCond.notify_one();
@@ -149,21 +147,22 @@ namespace create {
       callback();
   }
 
-  void Serial::onData(const boost::system::error_code& e, const std::size_t& size) {
-    if (e) {
-      CERR("[create::Serial] ", "serial error - " << e.message());
-      return;
-    }
-
-    // Should have read exactly one byte
-    if (size == 1) {
-      processByte(byteRead);
-    } // end if (size == 1)
+  void Serial::onData() {
+    // TODO check for program interrupt
+    while (true) {
+      size_t size = 0u;
+      try {
+        size = serial.read(&byteRead, 1);
+      } catch (const std::runtime_error & e) {
+        CERR("[create::Serial] ", "serial error - " << e.what());
+        continue;
+      }
 
-    // Read the next byte
-    boost::asio::async_read(port,
-                            boost::asio::buffer(&byteRead, 1),
-                            boost::bind(&Serial::onData, shared_from_this(), _1, _2));
+      // Should have read exactly one byte
+      if (size == 1) {
+        processByte(byteRead);
+      }
+    }
   }
 
   bool Serial::send(const uint8_t* bytes, unsigned int numBytes) {
@@ -171,8 +170,7 @@ namespace create {
       CERR("[create::Serial] ", "send failed, not connected.");
       return false;
     }
-    // TODO: catch boost exceptions
-    boost::asio::write(port, boost::asio::buffer(bytes, numBytes));
+    serial.write(bytes, static_cast<size_t>(numBytes));
     return true;
   }
 
diff --git a/src/serial_query.cpp b/src/serial_query.cpp
index 987cd26..078ebe8 100644
--- a/src/serial_query.cpp
+++ b/src/serial_query.cpp
@@ -1,4 +1,5 @@
 #include <iostream>
+#include <memory>
 
 #include "create/serial_query.h"
 #include "create/types.h"
@@ -7,8 +8,8 @@
 
 namespace create {
 
-  SerialQuery::SerialQuery(boost::shared_ptr<Data> d) : Serial(d),
-    streamRecoveryTimer(io),
+  SerialQuery::SerialQuery(std::shared_ptr<Data> d) : Serial(d),
+    // streamRecoveryTimer(io),
     packetID(ID_BUMP_WHEELDROP),
     packetByte(0),
     packetData(0),
@@ -29,22 +30,23 @@ namespace create {
     flushInput();
     send(requestPacket, 2);
     // Automatically resend request if no response is received
-    streamRecoveryTimer.expires_from_now(boost::posix_time::milliseconds(50));
-    streamRecoveryTimer.async_wait(boost::bind(&SerialQuery::restartSensorStream, this, _1));
+    // TODO: implement recovery timer
+    // streamRecoveryTimer.expires_from_now(boost::posix_time::milliseconds(50));
+    // streamRecoveryTimer.async_wait(
+    //   std::bind(&SerialQuery::restartSensorStream, this, std::placeholders::_1));
   }
 
-  void SerialQuery::restartSensorStream(const boost::system::error_code& err) {
-    if (err != boost::asio::error::operation_aborted) {
-      if (packetID != ID_BUMP_WHEELDROP) {
-        ++corruptPackets;
-      }
-      requestSensorData();
-    }
-  }
+  // void SerialQuery::restartSensorStream(const boost::system::error_code& err) {
+  //   if (err != boost::asio::error::operation_aborted) {
+  //     if (packetID != ID_BUMP_WHEELDROP) {
+  //       ++corruptPackets;
+  //     }
+  //     requestSensorData();
+  //   }
+  // }
 
   void SerialQuery::flushInput() {
-    // Only works with POSIX support
-    tcflush(port.lowest_layer().native_handle(), TCIFLUSH);
+    serial.flushInput();
   }
 
   void SerialQuery::processByte(uint8_t byteRead) {
diff --git a/src/serial_stream.cpp b/src/serial_stream.cpp
index 6cd8ea3..4475e94 100644
--- a/src/serial_stream.cpp
+++ b/src/serial_stream.cpp
@@ -1,11 +1,13 @@
+#include <cassert>
 #include <iostream>
+#include <memory>
 
 #include "create/serial_stream.h"
 #include "create/types.h"
 
 namespace create {
 
-  SerialStream::SerialStream(boost::shared_ptr<Data> d, const uint8_t& header) : Serial(d), readState(READ_HEADER), headerByte(header) {
+  SerialStream::SerialStream(std::shared_ptr<Data> d, const uint8_t& header) : Serial(d), readState(READ_HEADER), headerByte(header) {
   }
 
   bool SerialStream::startSensorStream() {
diff --git a/tests/test_create.cpp b/tests/test_create.cpp
index 57e76e8..aaa8a26 100644
--- a/tests/test_create.cpp
+++ b/tests/test_create.cpp
@@ -33,8 +33,6 @@ POSSIBILITY OF SUCH DAMAGE.
 
 #include "gtest/gtest.h"
 
-#include <boost/shared_ptr.hpp>
-
 TEST(CreateTest, ConstructorSingleParam)
 {
   create::Create create_default;
diff --git a/tests/test_data.cpp b/tests/test_data.cpp
index 8f893fe..fd7f79b 100644
--- a/tests/test_data.cpp
+++ b/tests/test_data.cpp
@@ -34,7 +34,7 @@ POSSIBILITY OF SUCH DAMAGE.
 
 #include "gtest/gtest.h"
 
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 TEST(DataTest, Constructor)
 {
@@ -76,31 +76,31 @@ TEST(DataTest, GetPacket)
 {
   // Get a packet exclusive to V_1
   create::Data data_v_1(create::V_1);
-  boost::shared_ptr<create::Packet> v_1_packet_ptr = data_v_1.getPacket(create::ID_OVERCURRENTS);
-  EXPECT_NE(v_1_packet_ptr, boost::shared_ptr<create::Packet>())
+  std::shared_ptr<create::Packet> v_1_packet_ptr = data_v_1.getPacket(create::ID_OVERCURRENTS);
+  EXPECT_NE(v_1_packet_ptr, std::shared_ptr<create::Packet>())
       << "ID_OVERCURRENTS packet not found for protocol V_1";
   EXPECT_EQ(static_cast<int>(v_1_packet_ptr->nbytes), 1);
   EXPECT_EQ(v_1_packet_ptr->info, std::string("overcurrents"));
 
   // Get a packet for V_2
   create::Data data_v_2(create::V_2);
-  boost::shared_ptr<create::Packet> v_2_packet_ptr = data_v_2.getPacket(create::ID_DISTANCE);
-  EXPECT_NE(v_2_packet_ptr, boost::shared_ptr<create::Packet>())
+  std::shared_ptr<create::Packet> v_2_packet_ptr = data_v_2.getPacket(create::ID_DISTANCE);
+  EXPECT_NE(v_2_packet_ptr, std::shared_ptr<create::Packet>())
       << "ID_DISTANCE packet not found for protocol V_2";
   EXPECT_EQ(static_cast<int>(v_2_packet_ptr->nbytes), 2);
   EXPECT_EQ(v_2_packet_ptr->info, std::string("distance"));
 
   // Get a packet exclusive to V_3
   create::Data data_v_3(create::V_3);
-  boost::shared_ptr<create::Packet> v_3_packet_ptr = data_v_3.getPacket(create::ID_LIGHT_FRONT_RIGHT);
-  EXPECT_NE(v_3_packet_ptr, boost::shared_ptr<create::Packet>())
+  std::shared_ptr<create::Packet> v_3_packet_ptr = data_v_3.getPacket(create::ID_LIGHT_FRONT_RIGHT);
+  EXPECT_NE(v_3_packet_ptr, std::shared_ptr<create::Packet>())
       << "ID_LIGHT_FRONT_RIGHT packet not found for protocol V_3";
   EXPECT_EQ(static_cast<int>(v_3_packet_ptr->nbytes), 2);
   EXPECT_EQ(v_3_packet_ptr->info, std::string("light_bumper_front_right"));
 
   // Get a non-existent packet
-  boost::shared_ptr<create::Packet> not_a_packet_ptr = data_v_3.getPacket(60);
-  EXPECT_EQ(not_a_packet_ptr, boost::shared_ptr<create::Packet>());
+  std::shared_ptr<create::Packet> not_a_packet_ptr = data_v_3.getPacket(60);
+  EXPECT_EQ(not_a_packet_ptr, std::shared_ptr<create::Packet>());
 }
 
 TEST(DataTest, GetPacketIDs)
diff --git a/tests/test_serial_query.cpp b/tests/test_serial_query.cpp
index 3527bb9..b88b101 100644
--- a/tests/test_serial_query.cpp
+++ b/tests/test_serial_query.cpp
@@ -33,17 +33,17 @@ POSSIBILITY OF SUCH DAMAGE.
 
 #include "gtest/gtest.h"
 
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 TEST(SerialQueryTest, Constructor)
 {
-  boost::shared_ptr<create::Data> data_ptr = boost::make_shared<create::Data>();
+  std::shared_ptr<create::Data> data_ptr = std::make_shared<create::Data>();
   create::SerialQuery serial_query(data_ptr);
 }
 
 TEST(SerialQueryTest, Connected)
 {
-  boost::shared_ptr<create::Data> data_ptr = boost::make_shared<create::Data>();
+  std::shared_ptr<create::Data> data_ptr = std::make_shared<create::Data>();
   create::SerialQuery serial_query(data_ptr);
 
   // Did not call connect and nothing to connect to, so expect false
@@ -52,7 +52,7 @@ TEST(SerialQueryTest, Connected)
 
 TEST(SerialQueryTest, Disconnect)
 {
-  boost::shared_ptr<create::Data> data_ptr = boost::make_shared<create::Data>();
+  std::shared_ptr<create::Data> data_ptr = std::make_shared<create::Data>();
   create::SerialQuery serial_query(data_ptr);
 
   // Not connected, but should not fail
@@ -61,7 +61,7 @@ TEST(SerialQueryTest, Disconnect)
 
 TEST(SerialQueryTest, NumPackets)
 {
-  boost::shared_ptr<create::Data> data_ptr = boost::make_shared<create::Data>();
+  std::shared_ptr<create::Data> data_ptr = std::make_shared<create::Data>();
   create::SerialQuery serial_query(data_ptr);
 
   // Not connected, so zero packets should have been received
@@ -71,7 +71,7 @@ TEST(SerialQueryTest, NumPackets)
 
 TEST(SerialQueryTest, Send)
 {
-  boost::shared_ptr<create::Data> data_ptr = boost::make_shared<create::Data>();
+  std::shared_ptr<create::Data> data_ptr = std::make_shared<create::Data>();
   create::SerialQuery serial_query(data_ptr);
 
   // Some bytes to send (to set date)
@@ -82,7 +82,7 @@ TEST(SerialQueryTest, Send)
 
 TEST(SerialQueryTest, SendOpcode)
 {
-  boost::shared_ptr<create::Data> data_ptr = boost::make_shared<create::Data>();
+  std::shared_ptr<create::Data> data_ptr = std::make_shared<create::Data>();
   create::SerialQuery serial_query(data_ptr);
 
   // Not connected, so failure expected
diff --git a/tests/test_serial_stream.cpp b/tests/test_serial_stream.cpp
index 7445939..9ae789c 100644
--- a/tests/test_serial_stream.cpp
+++ b/tests/test_serial_stream.cpp
@@ -33,17 +33,17 @@ POSSIBILITY OF SUCH DAMAGE.
 
 #include "gtest/gtest.h"
 
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 TEST(SerialStreamTest, Constructor)
 {
-  boost::shared_ptr<create::Data> data_ptr = boost::make_shared<create::Data>();
+  std::shared_ptr<create::Data> data_ptr = std::make_shared<create::Data>();
   create::SerialStream serial_stream(data_ptr);
 }
 
 TEST(SerialStreamTest, Connected)
 {
-  boost::shared_ptr<create::Data> data_ptr = boost::make_shared<create::Data>();
+  std::shared_ptr<create::Data> data_ptr = std::make_shared<create::Data>();
   create::SerialStream serial_stream(data_ptr);
 
   // Did not call connect and nothing to connect to, so expect false
@@ -52,7 +52,7 @@ TEST(SerialStreamTest, Connected)
 
 TEST(SerialStreamTest, Disconnect)
 {
-  boost::shared_ptr<create::Data> data_ptr = boost::make_shared<create::Data>();
+  std::shared_ptr<create::Data> data_ptr = std::make_shared<create::Data>();
   create::SerialStream serial_stream(data_ptr);
 
   // Not connected, but should not fail
@@ -61,7 +61,7 @@ TEST(SerialStreamTest, Disconnect)
 
 TEST(SerialStreamTest, NumPackets)
 {
-  boost::shared_ptr<create::Data> data_ptr = boost::make_shared<create::Data>();
+  std::shared_ptr<create::Data> data_ptr = std::make_shared<create::Data>();
   create::SerialStream serial_stream(data_ptr);
 
   // Not connected, so zero packets should have been received
@@ -71,7 +71,7 @@ TEST(SerialStreamTest, NumPackets)
 
 TEST(SerialStreamTest, Send)
 {
-  boost::shared_ptr<create::Data> data_ptr = boost::make_shared<create::Data>();
+  std::shared_ptr<create::Data> data_ptr = std::make_shared<create::Data>();
   create::SerialStream serial_stream(data_ptr);
 
   // Some bytes to send (to set date)
@@ -82,7 +82,7 @@ TEST(SerialStreamTest, Send)
 
 TEST(SerialStreamTest, SendOpcode)
 {
-  boost::shared_ptr<create::Data> data_ptr = boost::make_shared<create::Data>();
+  std::shared_ptr<create::Data> data_ptr = std::make_shared<create::Data>();
   create::SerialStream serial_stream(data_ptr);
 
   // Not connected, so failure expected