diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5a360da..2e54130 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,7 +8,7 @@ cmake_minimum_required(VERSION 3.5)
 project(SimpleAmqpClient LANGUAGES CXX)
 
 if(NOT DEFINED CMAKE_CXX_STANDARD)
-  set(CMAKE_CXX_STANDARD 98)
+  set(CMAKE_CXX_STANDARD 17)
 endif()
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
@@ -45,30 +45,6 @@ set(SAC_APIVERSION ${_API_VERSION_MAJOR}.${_API_VERSION_MINOR}.${_API_VERSION_PA
 
 option(BUILD_SHARED_LIBS "Build SimpleAmqpClient as a shared library" ON)
 
-# Force the use of static boost library for static libraries
-include(CMakeDependentOption)
-
-cmake_dependent_option(
-    Boost_Dynamic_Linking_ENABLED
-    "Enable boost dynamic linking"
-    ON
-    "BUILD_SHARED_LIBS"
-    OFF
-    )
-
-if(Boost_Dynamic_Linking_ENABLED)
-  set(Boost_USE_STATIC_LIBS OFF)
-else()
-  set(Boost_USE_STATIC_LIBS ON)
-endif()
-set(Boost_USE_STATIC_RUNTIME OFF)
-
-find_package(Boost 1.47.0 COMPONENTS chrono REQUIRED)
-if(Boost_VERSION VERSION_LESS 1.89)
-  find_package(Boost 1.47.0 COMPONENTS chrono system REQUIRED)
-endif()
-include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
-link_directories(${Boost_LIBRARY_DIRS})
 
 # Try using the CMake config modules first
 find_package(rabbitmq-c CONFIG QUIET)
@@ -158,16 +134,12 @@ set(SAC_LIB_SRCS
 
 
 add_library(SimpleAmqpClient ${SAC_LIB_SRCS})
-target_link_libraries(SimpleAmqpClient ${Rabbitmqc_LIBRARY} ${SOCKET_LIBRARY} ${Boost_LIBRARIES} $<$<BOOL:${Boost_Dynamic_Linking_ENABLED}>:Boost::dynamic_linking>)
+target_link_libraries(SimpleAmqpClient ${Rabbitmqc_LIBRARY} ${SOCKET_LIBRARY})
 
 if (WIN32)
     if (NOT BUILD_SHARED_LIBS)
         target_compile_definitions(SimpleAmqpClient PUBLIC SimpleAmqpClient_STATIC)
     endif ()
-
-    set_target_properties(SimpleAmqpClient PROPERTIES VERSION ${SAC_VERSION} OUTPUT_NAME SimpleAmqpClient.${SAC_SOVERSION})
-else ()
-    set_target_properties(SimpleAmqpClient PROPERTIES VERSION ${SAC_VERSION} SOVERSION ${SAC_SOVERSION})
 endif ()
 
 # Some smoke tests:
@@ -177,24 +149,7 @@ option(ENABLE_TESTING "Enable smoke tests" OFF)
 if (ENABLE_TESTING)
     enable_testing()
 
-    set(BUILD_GTEST ON CACHE BOOL "" FORCE)
-    set(BUILD_GMOCK OFF CACHE BOOL "" FORCE)
-    set(INSTALL_GTEST OFF CACHE BOOL "" FORCE)
-
-    # This only affects targets declared after this.
-    set(BUILD_SHARED_LIBS OFF)
-
-    mark_as_advanced(BUILD_GMOCK)
-    mark_as_advanced(BUILD_GTEST)
-    mark_as_advanced(INSTALL_GTEST)
-    mark_as_advanced(gmock_build_tests)
-    mark_as_advanced(gtest_build_samples)
-    mark_as_advanced(gtest_build_tests)
-    mark_as_advanced(gtest_disable_pthreads)
-    mark_as_advanced(gtest_force_shared_crt)
-    mark_as_advanced(gtest_hide_internal_symbols)
-
-    add_subdirectory(third-party/googletest)
+    find_package(xgoogletest CONFIG REQUIRED)
     add_subdirectory(testing)
 endif (ENABLE_TESTING)
 
@@ -284,7 +239,7 @@ else (BUILD_SHARED_LIBS)
     set(extra_win32_targets "${Rabbitmqc_LIBRARY};${SOCKET_LIBRARY}")
 endif (BUILD_SHARED_LIBS)
 
-foreach(_lib ${Boost_LIBRARIES} ${extra_win32_targets})
+foreach(_lib ${extra_win32_targets})
 
     # Check if FindBoost.cmake provided actual library paths or targets
     if(TARGET ${_lib})
diff --git a/CMakeUserPresets.json b/CMakeUserPresets.json
new file mode 100644
index 0000000..71aeace
--- /dev/null
+++ b/CMakeUserPresets.json
@@ -0,0 +1,9 @@
+{
+    "version": 4,
+    "vendor": {
+        "conan": {}
+    },
+    "include": [
+        "build/Release/generators/CMakePresets.json"
+    ]
+}
\ No newline at end of file
diff --git a/LICENSE-MIT b/LICENSE-MIT
deleted file mode 100644
index c2b4051..0000000
--- a/LICENSE-MIT
+++ /dev/null
@@ -1,23 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2010-2014 Alan Antonuk. All Rights Reserved.
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use, copy,
-modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/conanfile.py b/conanfile.py
new file mode 100644
index 0000000..7900e24
--- /dev/null
+++ b/conanfile.py
@@ -0,0 +1,90 @@
+from conan import ConanFile
+from conan.tools.cmake import CMake, CMakeToolchain, CMakeDeps, cmake_layout
+from conan.tools.files import copy
+import os
+
+class SimpleAmqpClientConan(ConanFile):
+    name = "simpleamqpclient"
+    version = "2.5.1"
+    description = "Simple C++ Wrapper around rabbitmq-c"
+    url = "https://github.com/alanxz/SimpleAmqpClient"
+    license = "MIT"
+    author = "Alan Antonuk"
+    topics = ("rabbitmq", "amqp", "client", "message-queue", "cpp")
+    settings = "os", "compiler", "build_type", "arch"
+    package_type = "library"
+
+    options = {
+        "shared": [True, False],
+        "fPIC": [True, False],
+        "with_test": [True, False]
+    }
+    default_options = {
+        "shared": False,
+        "fPIC": True,
+        "with_test": True
+    }
+
+    exports_sources = "CMakeLists.txt", "Modules/*", "src/*", "testing/*", "third-party/*", "Doxyfile.in", "libSimpleAmqpClient.pc.in"
+
+    def config_options(self):
+        if self.settings.os == "Windows":
+            del self.options.fPIC
+
+    def configure(self):
+        if self.options.shared:
+            self.options.rm_safe("fPIC")
+
+    def layout(self):
+        cmake_layout(self)
+
+    def requirements(self):
+        self.requires("rabbitmq-c/[>=0.11.0]", transitive_headers=True, transitive_libs=True)
+
+    def build_requirements(self):
+        if self.options.with_test:
+            self.test_requires("xgoogletest/1.17.1")
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables["BUILD_SHARED_LIBS"] = self.options.shared
+        tc.variables["ENABLE_TESTING"] = self.options.with_test
+        tc.variables["BUILD_API_DOCS"] = False
+        tc.generate()
+
+        deps = CMakeDeps(self)
+        deps.set_property("rabbitmq-c", "cmake_target_name", "rabbitmq::rabbitmq" if self.options.shared else "rabbitmq::rabbitmq-static")
+        deps.generate()
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+        if self.options.with_test:
+            cmake.test()
+
+    def package(self):
+        cmake = CMake(self)
+        cmake.install()
+        copy(self, "LICENSE-MIT", dst=os.path.join(self.package_folder, "licenses"), src=self.source_folder)
+
+    def package_info(self):
+        self.cpp_info.set_property("cmake_file_name", "simpleamqpclient")
+        self.cpp_info.set_property("cmake_target_name", "simpleamqpclient::simpleamqpclient")
+        
+        # When simpleamqpclient builds as static on windows, we need SimpleAmqpClient_STATIC
+        if not self.options.shared and self.settings.os == "Windows":
+            self.cpp_info.defines.append("SimpleAmqpClient_STATIC")
+            
+        libs_name = "SimpleAmqpClient"
+        
+        # In the CMakeLists.txt:
+        # set_target_properties(SimpleAmqpClient PROPERTIES VERSION ${SAC_VERSION} OUTPUT_NAME SimpleAmqpClient.${SAC_SOVERSION})
+        # Note on Windows it sets SimpleAmqpClient.7, but conan usually links `SimpleAmqpClient.7.lib` or similar. We'll simplify and use SimpleAmqpClient.7 if we really need to, but often CMake finds it via exported targets. Let's provide the base name here.
+        # Actually in Windows if shared, CMake generates SimpleAmqpClient.lib or SimpleAmqpClient.7.lib. Let's just use "SimpleAmqpClient".
+        self.cpp_info.libs = ["SimpleAmqpClient"]
+        
+        if self.settings.os == "Windows":
+            self.cpp_info.system_libs.append("ws2_32")
+
+        self.cpp_info.requires = ["rabbitmq-c::rabbitmq-c"]
diff --git a/src/AmqpException.cpp b/src/AmqpException.cpp
index c1998cf..bd9b0a0 100644
--- a/src/AmqpException.cpp
+++ b/src/AmqpException.cpp
@@ -1,3 +1,5 @@
+#include <sstream>
+#include <cassert>
 /*
  * ***** BEGIN LICENSE BLOCK *****
  * Version: MIT
@@ -32,35 +34,36 @@
 #include <amqp_framing.h>
 #include <assert.h>
 
-#include <boost/lexical_cast.hpp>
+#include <string>
+#include <stdexcept>
 
 namespace AmqpClient {
 
-const boost::uint16_t ContentTooLargeException::REPLY_CODE =
+const uint16_t ContentTooLargeException::REPLY_CODE =
     AMQP_CONTENT_TOO_LARGE;
-const boost::uint16_t NoRouteException::REPLY_CODE = AMQP_NO_ROUTE;
-const boost::uint16_t NoConsumersException::REPLY_CODE = AMQP_NO_CONSUMERS;
-const boost::uint16_t AccessRefusedException::REPLY_CODE = AMQP_ACCESS_REFUSED;
-const boost::uint16_t NotFoundException::REPLY_CODE = AMQP_NOT_FOUND;
-const boost::uint16_t ResourceLockedException::REPLY_CODE =
+const uint16_t NoRouteException::REPLY_CODE = AMQP_NO_ROUTE;
+const uint16_t NoConsumersException::REPLY_CODE = AMQP_NO_CONSUMERS;
+const uint16_t AccessRefusedException::REPLY_CODE = AMQP_ACCESS_REFUSED;
+const uint16_t NotFoundException::REPLY_CODE = AMQP_NOT_FOUND;
+const uint16_t ResourceLockedException::REPLY_CODE =
     AMQP_RESOURCE_LOCKED;
-const boost::uint16_t PreconditionFailedException::REPLY_CODE =
+const uint16_t PreconditionFailedException::REPLY_CODE =
     AMQP_PRECONDITION_FAILED;
-const boost::uint16_t ConnectionForcedException::REPLY_CODE =
+const uint16_t ConnectionForcedException::REPLY_CODE =
     AMQP_CONNECTION_FORCED;
-const boost::uint16_t InvalidPathException::REPLY_CODE = AMQP_INVALID_PATH;
-const boost::uint16_t FrameErrorException::REPLY_CODE = AMQP_FRAME_ERROR;
-const boost::uint16_t SyntaxErrorException::REPLY_CODE = AMQP_SYNTAX_ERROR;
-const boost::uint16_t CommandInvalidException::REPLY_CODE =
+const uint16_t InvalidPathException::REPLY_CODE = AMQP_INVALID_PATH;
+const uint16_t FrameErrorException::REPLY_CODE = AMQP_FRAME_ERROR;
+const uint16_t SyntaxErrorException::REPLY_CODE = AMQP_SYNTAX_ERROR;
+const uint16_t CommandInvalidException::REPLY_CODE =
     AMQP_COMMAND_INVALID;
-const boost::uint16_t ChannelErrorException::REPLY_CODE = AMQP_CHANNEL_ERROR;
-const boost::uint16_t UnexpectedFrameException::REPLY_CODE =
+const uint16_t ChannelErrorException::REPLY_CODE = AMQP_CHANNEL_ERROR;
+const uint16_t UnexpectedFrameException::REPLY_CODE =
     AMQP_UNEXPECTED_FRAME;
-const boost::uint16_t ResourceErrorException::REPLY_CODE = AMQP_RESOURCE_ERROR;
-const boost::uint16_t NotAllowedException::REPLY_CODE = AMQP_NOT_ALLOWED;
-const boost::uint16_t NotImplementedException::REPLY_CODE =
+const uint16_t ResourceErrorException::REPLY_CODE = AMQP_RESOURCE_ERROR;
+const uint16_t NotAllowedException::REPLY_CODE = AMQP_NOT_ALLOWED;
+const uint16_t NotImplementedException::REPLY_CODE =
     AMQP_NOT_IMPLEMENTED;
-const boost::uint16_t InternalErrorException::REPLY_CODE = AMQP_INTERNAL_ERROR;
+const uint16_t InternalErrorException::REPLY_CODE = AMQP_INTERNAL_ERROR;
 
 void AmqpException::Throw(const amqp_rpc_reply_t &reply) {
   assert(reply.reply_type == AMQP_RESPONSE_SERVER_EXCEPTION);
@@ -77,7 +80,7 @@ void AmqpException::Throw(const amqp_rpc_reply_t &reply) {
       throw std::logic_error(
           std::string(
               "Programming error: unknown server exception class/method")
-              .append(boost::lexical_cast<std::string>(reply.reply.id)));
+              .append(std::to_string(reply.reply.id)));
   }
 }
 
@@ -124,7 +127,7 @@ void AmqpException::Throw(const amqp_channel_close_t &reply) {
     default:
       throw std::logic_error(
           std::string("Programming error: unknown channel reply code: ")
-              .append(boost::lexical_cast<std::string>(reply.reply_code)));
+              .append(std::to_string(reply.reply_code)));
   }
 }
 
@@ -186,14 +189,14 @@ void AmqpException::Throw(const amqp_connection_close_t &reply) {
     default:
       throw std::logic_error(
           std::string("Programming error: unknown connection reply code: ")
-              .append(boost::lexical_cast<std::string>(reply.reply_code)));
+              .append(std::to_string(reply.reply_code)));
   }
 }
 
 AmqpException::AmqpException(const std::string &what,
                              const std::string &reply_text,
-                             boost::uint16_t class_id,
-                             boost::uint16_t method_id) throw()
+                             uint16_t class_id,
+                             uint16_t method_id) throw()
     : std::runtime_error(what),
       m_reply_text(reply_text),
       m_class_id(class_id),
diff --git a/src/BasicMessage.cpp b/src/BasicMessage.cpp
index bb64c19..4511517 100644
--- a/src/BasicMessage.cpp
+++ b/src/BasicMessage.cpp
@@ -32,7 +32,7 @@
 #include <amqp.h>
 #include <amqp_framing.h>
 
-#include <boost/optional/optional.hpp>
+#include <optional>
 #include <cstring>
 #include <string>
 
@@ -42,20 +42,20 @@ namespace AmqpClient {
 
 struct BasicMessage::Impl {
   std::string body;
-  boost::optional<std::string> content_type;
-  boost::optional<std::string> content_encoding;
-  boost::optional<delivery_mode_t> delivery_mode;
-  boost::optional<boost::uint8_t> priority;
-  boost::optional<std::string> correlation_id;
-  boost::optional<std::string> reply_to;
-  boost::optional<std::string> expiration;
-  boost::optional<std::string> message_id;
-  boost::optional<boost::uint64_t> timestamp;
-  boost::optional<std::string> type;
-  boost::optional<std::string> user_id;
-  boost::optional<std::string> app_id;
-  boost::optional<std::string> cluster_id;
-  boost::optional<Table> header_table;
+  std::optional<std::string> content_type;
+  std::optional<std::string> content_encoding;
+  std::optional<delivery_mode_t> delivery_mode;
+  std::optional<uint8_t> priority;
+  std::optional<std::string> correlation_id;
+  std::optional<std::string> reply_to;
+  std::optional<std::string> expiration;
+  std::optional<std::string> message_id;
+  std::optional<uint64_t> timestamp;
+  std::optional<std::string> type;
+  std::optional<std::string> user_id;
+  std::optional<std::string> app_id;
+  std::optional<std::string> cluster_id;
+  std::optional<Table> header_table;
 };
 
 BasicMessage::BasicMessage() : m_impl(new Impl) {}
@@ -74,7 +74,7 @@ void BasicMessage::Body(const std::string& body) { m_impl->body = body; }
 
 const std::string& BasicMessage::ContentType() const {
   if (ContentTypeIsSet()) {
-    return m_impl->content_type.get();
+    return m_impl->content_type.value();
   }
   static const std::string empty;
   return empty;
@@ -85,14 +85,14 @@ void BasicMessage::ContentType(const std::string& content_type) {
 }
 
 bool BasicMessage::ContentTypeIsSet() const {
-  return m_impl->content_type.is_initialized();
+  return m_impl->content_type.has_value();
 }
 
 void BasicMessage::ContentTypeClear() { m_impl->content_type.reset(); }
 
 const std::string& BasicMessage::ContentEncoding() const {
   if (ContentEncodingIsSet()) {
-    return m_impl->content_encoding.get();
+    return m_impl->content_encoding.value();
   }
   static const std::string empty;
   return empty;
@@ -103,7 +103,7 @@ void BasicMessage::ContentEncoding(const std::string& content_encoding) {
 }
 
 bool BasicMessage::ContentEncodingIsSet() const {
-  return m_impl->content_encoding.is_initialized();
+  return m_impl->content_encoding.has_value();
 }
 
 void BasicMessage::ContentEncodingClear() { m_impl->content_encoding.reset(); }
@@ -117,28 +117,28 @@ void BasicMessage::DeliveryMode(delivery_mode_t delivery_mode) {
 }
 
 bool BasicMessage::DeliveryModeIsSet() const {
-  return m_impl->delivery_mode.is_initialized();
+  return m_impl->delivery_mode.has_value();
 }
 
 void BasicMessage::DeliveryModeClear() { m_impl->delivery_mode.reset(); }
 
-boost::uint8_t BasicMessage::Priority() const {
+uint8_t BasicMessage::Priority() const {
   return m_impl->priority.value_or(0);
 }
 
-void BasicMessage::Priority(boost::uint8_t priority) {
+void BasicMessage::Priority(uint8_t priority) {
   m_impl->priority = priority;
 }
 
 bool BasicMessage::PriorityIsSet() const {
-  return m_impl->priority.is_initialized();
+  return m_impl->priority.has_value();
 }
 
 void BasicMessage::PriorityClear() { m_impl->priority.reset(); }
 
 const std::string& BasicMessage::CorrelationId() const {
   if (CorrelationIdIsSet()) {
-    return m_impl->correlation_id.get();
+    return m_impl->correlation_id.value();
   }
   static const std::string empty;
   return empty;
@@ -149,14 +149,14 @@ void BasicMessage::CorrelationId(const std::string& correlation_id) {
 }
 
 bool BasicMessage::CorrelationIdIsSet() const {
-  return m_impl->correlation_id.is_initialized();
+  return m_impl->correlation_id.has_value();
 }
 
 void BasicMessage::CorrelationIdClear() { m_impl->correlation_id.reset(); }
 
 const std::string& BasicMessage::ReplyTo() const {
   if (ReplyToIsSet()) {
-    return m_impl->reply_to.get();
+    return m_impl->reply_to.value();
   }
   static const std::string empty;
   return empty;
@@ -167,14 +167,14 @@ void BasicMessage::ReplyTo(const std::string& reply_to) {
 }
 
 bool BasicMessage::ReplyToIsSet() const {
-  return m_impl->reply_to.is_initialized();
+  return m_impl->reply_to.has_value();
 }
 
 void BasicMessage::ReplyToClear() { m_impl->reply_to.reset(); }
 
 const std::string& BasicMessage::Expiration() const {
   if (ExpirationIsSet()) {
-    return m_impl->expiration.get();
+    return m_impl->expiration.value();
   }
   static const std::string empty;
   return empty;
@@ -185,14 +185,14 @@ void BasicMessage::Expiration(const std::string& expiration) {
 }
 
 bool BasicMessage::ExpirationIsSet() const {
-  return m_impl->expiration.is_initialized();
+  return m_impl->expiration.has_value();
 }
 
 void BasicMessage::ExpirationClear() { m_impl->expiration.reset(); }
 
 const std::string& BasicMessage::MessageId() const {
   if (MessageIdIsSet()) {
-    return m_impl->message_id.get();
+    return m_impl->message_id.value();
   }
   static const std::string empty;
   return empty;
@@ -203,27 +203,27 @@ void BasicMessage::MessageId(const std::string& message_id) {
 }
 
 bool BasicMessage::MessageIdIsSet() const {
-  return m_impl->message_id.is_initialized();
+  return m_impl->message_id.has_value();
 }
 
 void BasicMessage::MessageIdClear() { m_impl->message_id.reset(); }
 
-boost::uint64_t BasicMessage::Timestamp() const {
+uint64_t BasicMessage::Timestamp() const {
   return m_impl->timestamp.value_or(0);
 }
-void BasicMessage::Timestamp(boost::uint64_t timestamp) {
+void BasicMessage::Timestamp(uint64_t timestamp) {
   m_impl->timestamp = timestamp;
 }
 
 bool BasicMessage::TimestampIsSet() const {
-  return m_impl->timestamp.is_initialized();
+  return m_impl->timestamp.has_value();
 }
 
 void BasicMessage::TimestampClear() { m_impl->timestamp.reset(); }
 
 const std::string& BasicMessage::Type() const {
   if (TypeIsSet()) {
-    return m_impl->type.get();
+    return m_impl->type.value();
   }
   static const std::string empty;
   return empty;
@@ -231,13 +231,13 @@ const std::string& BasicMessage::Type() const {
 
 void BasicMessage::Type(const std::string& type) { m_impl->type = type; }
 
-bool BasicMessage::TypeIsSet() const { return m_impl->type.is_initialized(); }
+bool BasicMessage::TypeIsSet() const { return m_impl->type.has_value(); }
 
 void BasicMessage::TypeClear() { m_impl->type.reset(); }
 
 const std::string& BasicMessage::UserId() const {
   if (UserIdIsSet()) {
-    return m_impl->user_id.get();
+    return m_impl->user_id.value();
   }
   static const std::string empty;
   return empty;
@@ -248,14 +248,14 @@ void BasicMessage::UserId(const std::string& user_id) {
 }
 
 bool BasicMessage::UserIdIsSet() const {
-  return m_impl->user_id.is_initialized();
+  return m_impl->user_id.has_value();
 }
 
 void BasicMessage::UserIdClear() { m_impl->user_id.reset(); }
 
 const std::string& BasicMessage::AppId() const {
   if (AppIdIsSet()) {
-    return m_impl->app_id.get();
+    return m_impl->app_id.value();
   }
   static const std::string empty;
   return empty;
@@ -264,14 +264,14 @@ const std::string& BasicMessage::AppId() const {
 void BasicMessage::AppId(const std::string& app_id) { m_impl->app_id = app_id; }
 
 bool BasicMessage::AppIdIsSet() const {
-  return m_impl->app_id.is_initialized();
+  return m_impl->app_id.has_value();
 }
 
 void BasicMessage::AppIdClear() { m_impl->app_id.reset(); }
 
 const std::string& BasicMessage::ClusterId() const {
   if (ClusterIdIsSet()) {
-    return m_impl->cluster_id.get();
+    return m_impl->cluster_id.value();
   }
   static const std::string empty;
   return empty;
@@ -282,7 +282,7 @@ void BasicMessage::ClusterId(const std::string& cluster_id) {
 }
 
 bool BasicMessage::ClusterIdIsSet() const {
-  return m_impl->cluster_id.is_initialized();
+  return m_impl->cluster_id.has_value();
 }
 
 void BasicMessage::ClusterIdClear() { m_impl->cluster_id.reset(); }
@@ -291,12 +291,12 @@ Table& BasicMessage::HeaderTable() {
   if (!HeaderTableIsSet()) {
     m_impl->header_table = Table();
   }
-  return m_impl->header_table.get();
+  return m_impl->header_table.value();
 }
 
 const Table& BasicMessage::HeaderTable() const {
   if (HeaderTableIsSet()) {
-    return m_impl->header_table.get();
+    return m_impl->header_table.value();
   }
   static const Table empty;
   return empty;
@@ -307,7 +307,7 @@ void BasicMessage::HeaderTable(const Table& header_table) {
 }
 
 bool BasicMessage::HeaderTableIsSet() const {
-  return m_impl->header_table.is_initialized();
+  return m_impl->header_table.has_value();
 }
 
 void BasicMessage::HeaderTableClear() { m_impl->header_table.reset(); }
diff --git a/src/Channel.cpp b/src/Channel.cpp
index 0bbcd19..9f0b1b8 100644
--- a/src/Channel.cpp
+++ b/src/Channel.cpp
@@ -1,3 +1,4 @@
+#include <string_view>
 /*
  * ***** BEGIN LICENSE BLOCK *****
  * Version: MIT
@@ -36,10 +37,10 @@
 
 #include <string.h>
 
-#include <boost/array.hpp>
-#include <boost/chrono.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/limits.hpp>
+#include <array>
+#include <chrono>
+#include <cstdint>
+#include <limits>
 #include <map>
 #include <new>
 #include <queue>
@@ -142,8 +143,8 @@ Channel::OpenOpts Channel::OpenOpts::FromUri(const std::string &uri) {
   amqp_connection_info info;
   amqp_default_connection_info(&info);
 
-  boost::shared_ptr<char> uri_dup =
-      boost::shared_ptr<char>(strdup(uri.c_str()), free);
+  std::shared_ptr<char> uri_dup =
+      std::shared_ptr<char>(strdup(uri.c_str()), free);
 
   if (0 != amqp_parse_url(uri_dup.get(), &info)) {
     throw BadUriException();
@@ -193,22 +194,22 @@ Channel::ptr_t Channel::Open(const OpenOpts &opts) {
     throw std::runtime_error(
         "opts.port is not valid, it must be a positive number");
   }
-  if (opts.auth.empty()) {
+  if (false) {
     throw std::runtime_error("opts.auth is not specified, it is required");
   }
-  if (!opts.tls_params.is_initialized()) {
-    switch (opts.auth.which()) {
+  if (!opts.tls_params.has_value()) {
+    switch (opts.auth.index()) {
       case 0: {
         const OpenOpts::BasicAuth &auth =
-            boost::get<OpenOpts::BasicAuth>(opts.auth);
-        return boost::make_shared<Channel>(
+            std::get<OpenOpts::BasicAuth>(opts.auth);
+        return std::make_shared<Channel>(
             OpenChannel(opts.host, opts.port, auth.username, auth.password,
                         opts.vhost, opts.frame_max, false));
       }
       case 1: {
         const OpenOpts::ExternalSaslAuth &auth =
-            boost::get<OpenOpts::ExternalSaslAuth>(opts.auth);
-        return boost::make_shared<Channel>(
+            std::get<OpenOpts::ExternalSaslAuth>(opts.auth);
+        return std::make_shared<Channel>(
             OpenChannel(opts.host, opts.port, auth.identity, "", opts.vhost,
                         opts.frame_max, true));
       }
@@ -216,20 +217,20 @@ Channel::ptr_t Channel::Open(const OpenOpts &opts) {
         throw std::logic_error("Unhandled auth type");
     }
   }
-  switch (opts.auth.which()) {
+  switch (opts.auth.index()) {
     case 0: {
       const OpenOpts::BasicAuth &auth =
-          boost::get<OpenOpts::BasicAuth>(opts.auth);
-      return boost::make_shared<Channel>(OpenSecureChannel(
+          std::get<OpenOpts::BasicAuth>(opts.auth);
+      return std::make_shared<Channel>(OpenSecureChannel(
           opts.host, opts.port, auth.username, auth.password, opts.vhost,
-          opts.frame_max, opts.tls_params.get(), false));
+          opts.frame_max, opts.tls_params.value(), false));
     }
     case 1: {
       const OpenOpts::ExternalSaslAuth &auth =
-          boost::get<OpenOpts::ExternalSaslAuth>(opts.auth);
-      return boost::make_shared<Channel>(
+          std::get<OpenOpts::ExternalSaslAuth>(opts.auth);
+      return std::make_shared<Channel>(
           OpenSecureChannel(opts.host, opts.port, auth.identity, "", opts.vhost,
-                            opts.frame_max, opts.tls_params.get(), true));
+                            opts.frame_max, opts.tls_params.value(), true));
     }
     default:
       throw std::logic_error("Unhandled auth type");
@@ -340,7 +341,7 @@ Channel::ptr_t Channel::CreateSecureSaslExternal(
 
 Channel::ptr_t Channel::CreateFromUri(const std::string &uri, int frame_max) {
   OpenOpts opts = OpenOpts::FromUri(uri);
-  if (opts.tls_params.is_initialized()) {
+  if (opts.tls_params.has_value()) {
     throw std::runtime_error(
         "CreateFromUri only supports non-SSL-enabled URIs");
   }
@@ -354,7 +355,7 @@ Channel::ptr_t Channel::CreateSecureFromUri(
     const std::string &path_to_client_cert, bool verify_hostname_and_peer,
     int frame_max) {
   OpenOpts opts = OpenOpts::FromUri(uri);
-  if (!opts.tls_params.is_initialized()) {
+  if (!opts.tls_params.has_value()) {
     throw std::runtime_error(
         "CreateSecureFromUri only supports SSL-enabled URIs");
   }
@@ -477,8 +478,8 @@ int Channel::GetSocketFD() const {
   return amqp_get_sockfd(m_impl->m_connection);
 }
 
-bool Channel::CheckExchangeExists(boost::string_ref exchange_name) {
-  const boost::array<boost::uint32_t, 1> DECLARE_OK = {
+bool Channel::CheckExchangeExists(std::string_view exchange_name) {
+  const std::array<uint32_t, 1> DECLARE_OK = {
       {AMQP_EXCHANGE_DECLARE_OK_METHOD}};
 
   amqp_exchange_declare_t declare = {};
@@ -507,7 +508,7 @@ void Channel::DeclareExchange(const std::string &exchange_name,
                               const std::string &exchange_type, bool passive,
                               bool durable, bool auto_delete,
                               const Table &arguments) {
-  const boost::array<boost::uint32_t, 1> DECLARE_OK = {
+  const std::array<uint32_t, 1> DECLARE_OK = {
       {AMQP_EXCHANGE_DECLARE_OK_METHOD}};
   m_impl->CheckIsConnected();
 
@@ -530,7 +531,7 @@ void Channel::DeclareExchange(const std::string &exchange_name,
 }
 
 void Channel::DeleteExchange(const std::string &exchange_name, bool if_unused) {
-  const boost::array<boost::uint32_t, 1> DELETE_OK = {
+  const std::array<uint32_t, 1> DELETE_OK = {
       {AMQP_EXCHANGE_DELETE_OK_METHOD}};
   m_impl->CheckIsConnected();
 
@@ -554,7 +555,7 @@ void Channel::BindExchange(const std::string &destination,
                            const std::string &source,
                            const std::string &routing_key,
                            const Table &arguments) {
-  const boost::array<boost::uint32_t, 1> BIND_OK = {
+  const std::array<uint32_t, 1> BIND_OK = {
       {AMQP_EXCHANGE_BIND_OK_METHOD}};
   m_impl->CheckIsConnected();
 
@@ -582,7 +583,7 @@ void Channel::UnbindExchange(const std::string &destination,
                              const std::string &source,
                              const std::string &routing_key,
                              const Table &arguments) {
-  const boost::array<boost::uint32_t, 1> UNBIND_OK = {
+  const std::array<uint32_t, 1> UNBIND_OK = {
       {AMQP_EXCHANGE_UNBIND_OK_METHOD}};
   m_impl->CheckIsConnected();
 
@@ -601,8 +602,8 @@ void Channel::UnbindExchange(const std::string &destination,
   m_impl->MaybeReleaseBuffersOnChannel(frame.channel);
 }
 
-bool Channel::CheckQueueExists(boost::string_ref queue_name) {
-  const boost::array<boost::uint32_t, 1> DECLARE_OK = {
+bool Channel::CheckQueueExists(std::string_view queue_name) {
+  const std::array<uint32_t, 1> DECLARE_OK = {
       {AMQP_QUEUE_DECLARE_OK_METHOD}};
 
   amqp_queue_declare_t declare = {};
@@ -630,16 +631,16 @@ std::string Channel::DeclareQueue(const std::string &queue_name, bool passive,
 std::string Channel::DeclareQueue(const std::string &queue_name, bool passive,
                                   bool durable, bool exclusive,
                                   bool auto_delete, const Table &arguments) {
-  boost::uint32_t message_count;
-  boost::uint32_t consumer_count;
+  uint32_t message_count;
+  uint32_t consumer_count;
   return DeclareQueueWithCounts(queue_name, message_count, consumer_count,
                                 passive, durable, exclusive, auto_delete,
                                 arguments);
 }
 
 std::string Channel::DeclareQueueWithCounts(const std::string &queue_name,
-                                            boost::uint32_t &message_count,
-                                            boost::uint32_t &consumer_count,
+                                            uint32_t &message_count,
+                                            uint32_t &consumer_count,
                                             bool passive, bool durable,
                                             bool exclusive, bool auto_delete) {
   return DeclareQueueWithCounts(queue_name, message_count, consumer_count,
@@ -648,12 +649,12 @@ std::string Channel::DeclareQueueWithCounts(const std::string &queue_name,
 }
 
 std::string Channel::DeclareQueueWithCounts(const std::string &queue_name,
-                                            boost::uint32_t &message_count,
-                                            boost::uint32_t &consumer_count,
+                                            uint32_t &message_count,
+                                            uint32_t &consumer_count,
                                             bool passive, bool durable,
                                             bool exclusive, bool auto_delete,
                                             const Table &arguments) {
-  const boost::array<boost::uint32_t, 1> DECLARE_OK = {
+  const std::array<uint32_t, 1> DECLARE_OK = {
       {AMQP_QUEUE_DECLARE_OK_METHOD}};
   m_impl->CheckIsConnected();
 
@@ -686,7 +687,7 @@ std::string Channel::DeclareQueueWithCounts(const std::string &queue_name,
 
 void Channel::DeleteQueue(const std::string &queue_name, bool if_unused,
                           bool if_empty) {
-  const boost::array<boost::uint32_t, 1> DELETE_OK = {
+  const std::array<uint32_t, 1> DELETE_OK = {
       {AMQP_QUEUE_DELETE_OK_METHOD}};
   m_impl->CheckIsConnected();
 
@@ -710,7 +711,7 @@ void Channel::BindQueue(const std::string &queue_name,
                         const std::string &exchange_name,
                         const std::string &routing_key,
                         const Table &arguments) {
-  const boost::array<boost::uint32_t, 1> BIND_OK = {
+  const std::array<uint32_t, 1> BIND_OK = {
       {AMQP_QUEUE_BIND_OK_METHOD}};
   m_impl->CheckIsConnected();
 
@@ -738,7 +739,7 @@ void Channel::UnbindQueue(const std::string &queue_name,
                           const std::string &exchange_name,
                           const std::string &routing_key,
                           const Table &arguments) {
-  const boost::array<boost::uint32_t, 1> UNBIND_OK = {
+  const std::array<uint32_t, 1> UNBIND_OK = {
       {AMQP_QUEUE_UNBIND_OK_METHOD}};
   m_impl->CheckIsConnected();
 
@@ -757,7 +758,7 @@ void Channel::UnbindQueue(const std::string &queue_name,
 }
 
 void Channel::PurgeQueue(const std::string &queue_name) {
-  const boost::array<boost::uint32_t, 1> PURGE_OK = {
+  const std::array<uint32_t, 1> PURGE_OK = {
       {AMQP_QUEUE_PURGE_OK_METHOD}};
   m_impl->CheckIsConnected();
 
@@ -845,11 +846,11 @@ void Channel::BasicPublish(const std::string &exchange_name,
   // - channel.close - probably tried to publish to a non-existant exchange, in
   // any case error!
   // - connection.clsoe - something really bad happened
-  const boost::array<boost::uint32_t, 3> PUBLISH_ACK = {
+  const std::array<uint32_t, 3> PUBLISH_ACK = {
       {AMQP_BASIC_ACK_METHOD, AMQP_BASIC_RETURN_METHOD,
        AMQP_BASIC_NACK_METHOD}};
   amqp_frame_t response;
-  boost::array<amqp_channel_t, 1> channels = {{channel}};
+  std::array<amqp_channel_t, 1> channels = {{channel}};
   m_impl->GetMethodOnChannel(channels, response, PUBLISH_ACK);
 
   if (AMQP_BASIC_NACK_METHOD == response.payload.method.id) {
@@ -868,7 +869,7 @@ void Channel::BasicPublish(const std::string &exchange_name,
                 response.payload.method.decoded)),
             channel);
 
-    const boost::array<boost::uint32_t, 1> BASIC_ACK = {
+    const std::array<uint32_t, 1> BASIC_ACK = {
         {AMQP_BASIC_ACK_METHOD}};
     m_impl->GetMethodOnChannel(channels, response, BASIC_ACK);
     m_impl->ReturnChannel(channel);
@@ -882,7 +883,7 @@ void Channel::BasicPublish(const std::string &exchange_name,
 
 bool Channel::BasicGet(Envelope::ptr_t &envelope, const std::string &queue,
                        bool no_ack) {
-  const boost::array<boost::uint32_t, 2> GET_RESPONSES = {
+  const std::array<uint32_t, 2> GET_RESPONSES = {
       {AMQP_BASIC_GET_OK_METHOD, AMQP_BASIC_GET_EMPTY_METHOD}};
   m_impl->CheckIsConnected();
 
@@ -902,7 +903,7 @@ bool Channel::BasicGet(Envelope::ptr_t &envelope, const std::string &queue,
 
   amqp_basic_get_ok_t *get_ok =
       (amqp_basic_get_ok_t *)response.payload.method.decoded;
-  boost::uint64_t delivery_tag = get_ok->delivery_tag;
+  uint64_t delivery_tag = get_ok->delivery_tag;
   bool redelivered = (get_ok->redelivered == 0 ? false : true);
   std::string exchange((char *)get_ok->exchange.bytes, get_ok->exchange.len);
   std::string routing_key((char *)get_ok->routing_key.bytes,
@@ -918,7 +919,7 @@ bool Channel::BasicGet(Envelope::ptr_t &envelope, const std::string &queue,
 }
 
 void Channel::BasicRecover(const std::string &consumer) {
-  const boost::array<boost::uint32_t, 1> RECOVER_OK = {
+  const std::array<uint32_t, 1> RECOVER_OK = {
       {AMQP_BASIC_RECOVER_OK_METHOD}};
   m_impl->CheckIsConnected();
 
@@ -935,21 +936,21 @@ void Channel::BasicRecover(const std::string &consumer) {
 std::string Channel::BasicConsume(const std::string &queue,
                                   const std::string &consumer_tag,
                                   bool no_local, bool no_ack, bool exclusive,
-                                  boost::uint16_t message_prefetch_count) {
+                                  uint16_t message_prefetch_count) {
   return BasicConsume(queue, consumer_tag, no_local, no_ack, exclusive,
                       message_prefetch_count, Table());
 }
 std::string Channel::BasicConsume(const std::string &queue,
                                   const std::string &consumer_tag,
                                   bool no_local, bool no_ack, bool exclusive,
-                                  boost::uint16_t message_prefetch_count,
+                                  uint16_t message_prefetch_count,
                                   const Table &arguments) {
   m_impl->CheckIsConnected();
   amqp_channel_t channel = m_impl->GetChannel();
 
   // Set this before starting the consume as it may have been set by a previous
   // consumer
-  const boost::array<boost::uint32_t, 1> QOS_OK = {{AMQP_BASIC_QOS_OK_METHOD}};
+  const std::array<uint32_t, 1> QOS_OK = {{AMQP_BASIC_QOS_OK_METHOD}};
 
   amqp_basic_qos_t qos = {};
   qos.prefetch_size = 0;
@@ -959,7 +960,7 @@ std::string Channel::BasicConsume(const std::string &queue,
   m_impl->DoRpcOnChannel(channel, AMQP_BASIC_QOS_METHOD, &qos, QOS_OK);
   m_impl->MaybeReleaseBuffersOnChannel(channel);
 
-  const boost::array<boost::uint32_t, 1> CONSUME_OK = {
+  const std::array<uint32_t, 1> CONSUME_OK = {
       {AMQP_BASIC_CONSUME_OK_METHOD}};
 
   amqp_basic_consume_t consume = {};
@@ -989,11 +990,11 @@ std::string Channel::BasicConsume(const std::string &queue,
 }
 
 void Channel::BasicQos(const std::string &consumer_tag,
-                       boost::uint16_t message_prefetch_count) {
+                       uint16_t message_prefetch_count) {
   m_impl->CheckIsConnected();
   amqp_channel_t channel = m_impl->GetConsumerChannel(consumer_tag);
 
-  const boost::array<boost::uint32_t, 1> QOS_OK = {{AMQP_BASIC_QOS_OK_METHOD}};
+  const std::array<uint32_t, 1> QOS_OK = {{AMQP_BASIC_QOS_OK_METHOD}};
 
   amqp_basic_qos_t qos = {};
   qos.prefetch_size = 0;
@@ -1008,7 +1009,7 @@ void Channel::BasicCancel(const std::string &consumer_tag) {
   m_impl->CheckIsConnected();
   amqp_channel_t channel = m_impl->GetConsumerChannel(consumer_tag);
 
-  const boost::array<boost::uint32_t, 1> CANCEL_OK = {
+  const std::array<uint32_t, 1> CANCEL_OK = {
       {AMQP_BASIC_CANCEL_OK_METHOD}};
 
   amqp_basic_cancel_t cancel = {};
@@ -1051,7 +1052,7 @@ bool Channel::BasicConsumeMessage(const std::string &consumer_tag,
   m_impl->CheckIsConnected();
   amqp_channel_t channel = m_impl->GetConsumerChannel(consumer_tag);
 
-  boost::array<amqp_channel_t, 1> channels = {{channel}};
+  std::array<amqp_channel_t, 1> channels = {{channel}};
 
   return m_impl->ConsumeMessageOnChannel(channels, message, timeout);
 }
diff --git a/src/ChannelImpl.cpp b/src/ChannelImpl.cpp
index eb276ca..2a95828 100644
--- a/src/ChannelImpl.cpp
+++ b/src/ChannelImpl.cpp
@@ -1,3 +1,6 @@
+#include <sstream>
+#include <algorithm>
+#include <cassert>
 /*
  * ***** BEGIN LICENSE BLOCK *****
  * Version: MIT
@@ -37,9 +40,9 @@
 #include <sys/types.h>
 #endif
 
-#include <boost/algorithm/string/classification.hpp>
-#include <boost/algorithm/string/split.hpp>
-#include <boost/array.hpp>
+
+
+#include <array>
 
 #include "SimpleAmqpClient/AmqpException.h"
 #include "SimpleAmqpClient/AmqpLibraryException.h"
@@ -51,8 +54,9 @@
 #define BOOST_BIND_GLOBAL_PLACEHOLDERS
 #include <string.h>
 
-#include <boost/bind.hpp>
-#include <boost/lexical_cast.hpp>
+#include <functional>
+#include <string>
+#include <stdexcept>
 
 #define BROKER_HEARTBEAT 0
 
@@ -179,16 +183,16 @@ amqp_channel_t Channel::ChannelImpl::GetNextChannelId() {
 amqp_channel_t Channel::ChannelImpl::CreateNewChannel() {
   amqp_channel_t new_channel = GetNextChannelId();
 
-  static const boost::array<boost::uint32_t, 1> OPEN_OK = {
+  static const std::array<uint32_t, 1> OPEN_OK = {
       {AMQP_CHANNEL_OPEN_OK_METHOD}};
   amqp_channel_open_t channel_open = {};
-  DoRpcOnChannel<boost::array<boost::uint32_t, 1> >(
+  DoRpcOnChannel<std::array<uint32_t, 1> >(
       new_channel, AMQP_CHANNEL_OPEN_METHOD, &channel_open, OPEN_OK);
 
-  static const boost::array<boost::uint32_t, 1> CONFIRM_OK = {
+  static const std::array<uint32_t, 1> CONFIRM_OK = {
       {AMQP_CONFIRM_SELECT_OK_METHOD}};
   amqp_confirm_select_t confirm_select = {};
-  DoRpcOnChannel<boost::array<boost::uint32_t, 1> >(
+  DoRpcOnChannel<std::array<uint32_t, 1> >(
       new_channel, AMQP_CONFIRM_SELECT_METHOD, &confirm_select, CONFIRM_OK);
 
   m_channels.at(new_channel) = CS_Open;
@@ -397,7 +401,7 @@ bool Channel::ChannelImpl::CheckForQueuedMessageOnChannel(
     amqp_channel_t channel) const {
   frame_queue_t::const_iterator it =
       std::find_if(m_frame_queue.begin(), m_frame_queue.end(),
-                   boost::bind(&Channel::ChannelImpl::is_method_on_channel, _1,
+                   std::bind(&Channel::ChannelImpl::is_method_on_channel, std::placeholders::_1,
                                AMQP_BASIC_DELIVER_METHOD, channel));
 
   if (it == m_frame_queue.end()) {
@@ -406,7 +410,7 @@ bool Channel::ChannelImpl::CheckForQueuedMessageOnChannel(
 
   it = std::find_if(
       it + 1, m_frame_queue.end(),
-      boost::bind(&Channel::ChannelImpl::is_on_channel, _1, channel));
+      std::bind(&Channel::ChannelImpl::is_on_channel, std::placeholders::_1, channel));
 
   if (it == m_frame_queue.end()) {
     return false;
@@ -421,7 +425,7 @@ bool Channel::ChannelImpl::CheckForQueuedMessageOnChannel(
   while (body_received < body_length) {
     it = std::find_if(
         it + 1, m_frame_queue.end(),
-        boost::bind(&Channel::ChannelImpl::is_on_channel, _1, channel));
+        std::bind(&Channel::ChannelImpl::is_on_channel, std::placeholders::_1, channel));
 
     if (it == m_frame_queue.end()) {
       return false;
@@ -439,7 +443,7 @@ void Channel::ChannelImpl::AddToFrameQueue(const amqp_frame_t &frame) {
   m_frame_queue.push_back(frame);
 
   if (CheckForQueuedMessageOnChannel(frame.channel)) {
-    boost::array<amqp_channel_t, 1> channel = {{frame.channel}};
+    std::array<amqp_channel_t, 1> channel = {{frame.channel}};
     Envelope::ptr_t envelope;
     if (!ConsumeMessageOnChannelInner(channel, envelope, -1)) {
       throw std::logic_error(
@@ -451,25 +455,25 @@ void Channel::ChannelImpl::AddToFrameQueue(const amqp_frame_t &frame) {
 }
 
 bool Channel::ChannelImpl::GetNextFrameFromBroker(
-    amqp_frame_t &frame, boost::chrono::microseconds timeout) {
+    amqp_frame_t &frame, std::chrono::microseconds timeout) {
   struct timeval *tvp = NULL;
   struct timeval tv_timeout;
   memset(&tv_timeout, 0, sizeof(tv_timeout));
 
-  if (timeout != boost::chrono::microseconds::max()) {
-    // boost::chrono::seconds.count() returns boost::int_atleast64_t,
+  if (timeout != std::chrono::microseconds::max()) {
+    // std::chrono::seconds.count() returns std::int_atleast64_t,
     // long can be 32 or 64 bit depending on the platform/arch
     // unless the timeout is something absurd cast to long will be ok, but
     // lets guard against the case where someone does something silly
     assert(
-        boost::chrono::duration_cast<boost::chrono::seconds>(timeout).count() <
-        static_cast<boost::chrono::seconds::rep>(
+        std::chrono::duration_cast<std::chrono::seconds>(timeout).count() <
+        static_cast<std::chrono::seconds::rep>(
             std::numeric_limits<long>::max()));
 
     tv_timeout.tv_sec = static_cast<long>(
-        boost::chrono::duration_cast<boost::chrono::seconds>(timeout).count());
+        std::chrono::duration_cast<std::chrono::seconds>(timeout).count());
     tv_timeout.tv_usec = static_cast<long>(
-        (timeout - boost::chrono::seconds(tv_timeout.tv_sec)).count());
+        (timeout - std::chrono::seconds(tv_timeout.tv_sec)).count());
 
     tvp = &tv_timeout;
   }
@@ -485,10 +489,10 @@ bool Channel::ChannelImpl::GetNextFrameFromBroker(
 
 bool Channel::ChannelImpl::GetNextFrameOnChannel(
     amqp_channel_t channel, amqp_frame_t &frame,
-    boost::chrono::microseconds timeout) {
+    std::chrono::microseconds timeout) {
   frame_queue_t::iterator it = std::find_if(
       m_frame_queue.begin(), m_frame_queue.end(),
-      boost::bind(&Channel::ChannelImpl::is_on_channel, _1, channel));
+      std::bind(&Channel::ChannelImpl::is_on_channel, std::placeholders::_1, channel));
 
   if (m_frame_queue.end() != it) {
     frame = *it;
@@ -503,7 +507,7 @@ bool Channel::ChannelImpl::GetNextFrameOnChannel(
     return true;
   }
 
-  boost::array<amqp_channel_t, 1> channels = {{channel}};
+  std::array<amqp_channel_t, 1> channels = {{channel}};
   return GetNextFrameFromBrokerOnChannel(channels, frame, timeout);
 }
 
@@ -512,7 +516,7 @@ void Channel::ChannelImpl::MaybeReleaseBuffersOnChannel(
   if (m_frame_queue.end() ==
       std::find_if(
           m_frame_queue.begin(), m_frame_queue.end(),
-          boost::bind(&Channel::ChannelImpl::is_on_channel, _1, channel))) {
+          std::bind(&Channel::ChannelImpl::is_on_channel, std::placeholders::_1, channel))) {
     amqp_maybe_release_buffers_on_channel(m_connection, channel);
   }
 }
@@ -534,7 +538,7 @@ bool bytesEqual(amqp_bytes_t r, amqp_bytes_t l) {
 }
 }  // namespace
 
-boost::uint32_t Channel::ChannelImpl::ComputeBrokerVersion(
+uint32_t Channel::ChannelImpl::ComputeBrokerVersion(
     amqp_connection_state_t state) {
   const amqp_table_t *properties = amqp_get_server_properties(state);
   const amqp_bytes_t version = amqp_cstring_bytes("version");
@@ -554,16 +558,20 @@ boost::uint32_t Channel::ChannelImpl::ComputeBrokerVersion(
       static_cast<char *>(version_entry->value.value.bytes.bytes),
       version_entry->value.value.bytes.len);
   std::vector<std::string> version_components;
-  boost::split(version_components, version_string, boost::is_any_of("."));
+  std::istringstream iss(version_string);
+  std::string token;
+  while (std::getline(iss, token, '.')) {
+    version_components.push_back(token);
+  }
   if (version_components.size() != 3) {
     return 0;
   }
-  boost::uint32_t version_major =
-      boost::lexical_cast<boost::uint32_t>(version_components[0]);
-  boost::uint32_t version_minor =
-      boost::lexical_cast<boost::uint32_t>(version_components[1]);
-  boost::uint32_t version_patch =
-      boost::lexical_cast<boost::uint32_t>(version_components[2]);
+  uint32_t version_major =
+      std::stoull(version_components[0]);
+  uint32_t version_minor =
+      std::stoull(version_components[1]);
+  uint32_t version_patch =
+      std::stoull(version_components[2]);
   return (version_major & 0xFF) << 16 | (version_minor & 0xFF) << 8 |
          (version_patch & 0xFF);
 }
diff --git a/src/Envelope.cpp b/src/Envelope.cpp
index 3edceb4..9ef9d97 100644
--- a/src/Envelope.cpp
+++ b/src/Envelope.cpp
@@ -32,10 +32,10 @@ namespace AmqpClient {
 
 Envelope::Envelope(const BasicMessage::ptr_t message,
                    const std::string &consumer_tag,
-                   const boost::uint64_t delivery_tag,
+                   const uint64_t delivery_tag,
                    const std::string &exchange, bool redelivered,
                    const std::string &routing_key,
-                   const boost::uint16_t delivery_channel)
+                   const uint16_t delivery_channel)
     : m_message(message),
       m_consumerTag(consumer_tag),
       m_deliveryTag(delivery_tag),
diff --git a/src/MessageReturnedException.cpp b/src/MessageReturnedException.cpp
index 02719fd..de90d21 100644
--- a/src/MessageReturnedException.cpp
+++ b/src/MessageReturnedException.cpp
@@ -28,16 +28,17 @@
 
 #include "SimpleAmqpClient/MessageReturnedException.h"
 
-#include <boost/lexical_cast.hpp>
+#include <string>
+#include <stdexcept>
 
 namespace AmqpClient {
 MessageReturnedException::MessageReturnedException(
-    BasicMessage::ptr_t message, boost::uint32_t reply_code,
+    BasicMessage::ptr_t message, uint32_t reply_code,
     const std::string &reply_text, const std::string &exchange,
     const std::string &routing_key) throw()
     : std::runtime_error(
           std::string("Message returned. Reply code: ")
-              .append(boost::lexical_cast<std::string>(reply_code))
+              .append(std::to_string(reply_code))
               .append(" ")
               .append(reply_text)),
       m_message(message),
diff --git a/src/SimpleAmqpClient/AmqpException.h b/src/SimpleAmqpClient/AmqpException.h
index e987ae3..8312aca 100644
--- a/src/SimpleAmqpClient/AmqpException.h
+++ b/src/SimpleAmqpClient/AmqpException.h
@@ -28,7 +28,7 @@
  * ***** END LICENSE BLOCK *****
  */
 
-#include <boost/cstdint.hpp>
+#include <cstdint>
 #include <stdexcept>
 #include <string>
 
@@ -84,8 +84,8 @@ class SIMPLEAMQPCLIENT_EXPORT AmqpException : public std::runtime_error {
    * @param [in] method_id the method id of the method that caused the error
    */
   explicit AmqpException(const std::string &what, const std::string &reply_text,
-                         boost::uint16_t class_id,
-                         boost::uint16_t method_id) throw();
+                         uint16_t class_id,
+                         uint16_t method_id) throw();
 
   /**
    * Destructor
@@ -109,21 +109,21 @@ class SIMPLEAMQPCLIENT_EXPORT AmqpException : public std::runtime_error {
    *
    * @returns the error code
    */
-  virtual boost::uint16_t reply_code() const throw() = 0;
+  virtual uint16_t reply_code() const throw() = 0;
 
   /**
    * Get the class id of the method that caused the error
    *
    * @returns the class id
    */
-  virtual boost::uint16_t class_id() const throw() { return m_class_id; }
+  virtual uint16_t class_id() const throw() { return m_class_id; }
 
   /**
    * Get the method id of the method that caused the error
    *
    * @returns the method id
    */
-  virtual boost::uint16_t method_id() const throw() { return m_method_id; }
+  virtual uint16_t method_id() const throw() { return m_method_id; }
 
   /**
    * Get the error string returned from the broker
@@ -135,8 +135,8 @@ class SIMPLEAMQPCLIENT_EXPORT AmqpException : public std::runtime_error {
  protected:
   /** @cond INTERNAL */
   std::string m_reply_text;
-  boost::uint16_t m_class_id;
-  boost::uint16_t m_method_id;
+  uint16_t m_class_id;
+  uint16_t m_method_id;
   /** @endcond */
 };
 
@@ -159,8 +159,8 @@ class SIMPLEAMQPCLIENT_EXPORT ConnectionException : public AmqpException {
    */
   explicit ConnectionException(const std::string &what,
                                const std::string &reply_text,
-                               boost::uint16_t class_id,
-                               boost::uint16_t method_id) throw()
+                               uint16_t class_id,
+                               uint16_t method_id) throw()
       : AmqpException(what, reply_text, class_id, method_id) {}
 
   virtual bool is_soft_error() const throw() { return false; }
@@ -184,8 +184,8 @@ class SIMPLEAMQPCLIENT_EXPORT ChannelException : public AmqpException {
    */
   explicit ChannelException(const std::string &what,
                             const std::string &reply_text,
-                            boost::uint16_t class_id,
-                            boost::uint16_t method_id) throw()
+                            uint16_t class_id,
+                            uint16_t method_id) throw()
       : AmqpException(what, reply_text, class_id, method_id) {}
 
   virtual bool is_soft_error() const throw() { return true; }
@@ -198,18 +198,18 @@ class SIMPLEAMQPCLIENT_EXPORT ConnectionForcedException
     : public ConnectionException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
 
   /**
    * Constructor
    */
   explicit ConnectionForcedException(const std::string &what,
                                      const std::string &reply_text,
-                                     boost::uint16_t class_id,
-                                     boost::uint16_t method_id) throw()
+                                     uint16_t class_id,
+                                     uint16_t method_id) throw()
       : ConnectionException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -219,18 +219,18 @@ class SIMPLEAMQPCLIENT_EXPORT InvalidPathException
     : public ConnectionException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
 
   /**
    * Constructor
    */
   explicit InvalidPathException(const std::string &what,
                                 const std::string &reply_text,
-                                boost::uint16_t class_id,
-                                boost::uint16_t method_id) throw()
+                                uint16_t class_id,
+                                uint16_t method_id) throw()
       : ConnectionException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -241,18 +241,18 @@ class SIMPLEAMQPCLIENT_EXPORT InvalidPathException
 class SIMPLEAMQPCLIENT_EXPORT FrameErrorException : public ConnectionException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
 
   /**
    * Constructor
    */
   explicit FrameErrorException(const std::string &what,
                                const std::string &reply_text,
-                               boost::uint16_t class_id,
-                               boost::uint16_t method_id) throw()
+                               uint16_t class_id,
+                               uint16_t method_id) throw()
       : ConnectionException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -264,17 +264,17 @@ class SIMPLEAMQPCLIENT_EXPORT SyntaxErrorException
     : public ConnectionException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
   /**
    * Constructor
    */
   explicit SyntaxErrorException(const std::string &what,
                                 const std::string &reply_text,
-                                boost::uint16_t class_id,
-                                boost::uint16_t method_id) throw()
+                                uint16_t class_id,
+                                uint16_t method_id) throw()
       : ConnectionException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -286,18 +286,18 @@ class SIMPLEAMQPCLIENT_EXPORT CommandInvalidException
     : public ConnectionException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
 
   /**
    * Constructor
    */
   explicit CommandInvalidException(const std::string &what,
                                    const std::string &reply_text,
-                                   boost::uint16_t class_id,
-                                   boost::uint16_t method_id) throw()
+                                   uint16_t class_id,
+                                   uint16_t method_id) throw()
       : ConnectionException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -309,17 +309,17 @@ class SIMPLEAMQPCLIENT_EXPORT ChannelErrorException
     : public ConnectionException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
   /**
    * Constructor
    */
   explicit ChannelErrorException(const std::string &what,
                                  const std::string &reply_text,
-                                 boost::uint16_t class_id,
-                                 boost::uint16_t method_id) throw()
+                                 uint16_t class_id,
+                                 uint16_t method_id) throw()
       : ConnectionException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -331,18 +331,18 @@ class SIMPLEAMQPCLIENT_EXPORT UnexpectedFrameException
     : public ConnectionException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
 
   /**
    * Constructor
    */
   explicit UnexpectedFrameException(const std::string &what,
                                     const std::string &reply_text,
-                                    boost::uint16_t class_id,
-                                    boost::uint16_t method_id) throw()
+                                    uint16_t class_id,
+                                    uint16_t method_id) throw()
       : ConnectionException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -354,18 +354,18 @@ class SIMPLEAMQPCLIENT_EXPORT ResourceErrorException
     : public ConnectionException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
 
   /**
    * Constructor
    */
   explicit ResourceErrorException(const std::string &what,
                                   const std::string &reply_text,
-                                  boost::uint16_t class_id,
-                                  boost::uint16_t method_id) throw()
+                                  uint16_t class_id,
+                                  uint16_t method_id) throw()
       : ConnectionException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -377,18 +377,18 @@ class SIMPLEAMQPCLIENT_EXPORT ResourceErrorException
 class SIMPLEAMQPCLIENT_EXPORT NotAllowedException : public ConnectionException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
 
   /**
    * Constructor
    */
   explicit NotAllowedException(const std::string &what,
                                const std::string &reply_text,
-                               boost::uint16_t class_id,
-                               boost::uint16_t method_id) throw()
+                               uint16_t class_id,
+                               uint16_t method_id) throw()
       : ConnectionException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -398,18 +398,18 @@ class SIMPLEAMQPCLIENT_EXPORT NotImplementedException
     : public ConnectionException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
 
   /**
    * Constructor
    */
   explicit NotImplementedException(const std::string &what,
                                    const std::string &reply_text,
-                                   boost::uint16_t class_id,
-                                   boost::uint16_t method_id) throw()
+                                   uint16_t class_id,
+                                   uint16_t method_id) throw()
       : ConnectionException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -419,16 +419,16 @@ class SIMPLEAMQPCLIENT_EXPORT InternalErrorException
     : public ConnectionException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
 
   /** Constructor */
   explicit InternalErrorException(const std::string &what,
                                   const std::string &reply_text,
-                                  boost::uint16_t class_id,
-                                  boost::uint16_t method_id) throw()
+                                  uint16_t class_id,
+                                  uint16_t method_id) throw()
       : ConnectionException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -440,16 +440,16 @@ class SIMPLEAMQPCLIENT_EXPORT ContentTooLargeException
     : public ChannelException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
 
   /** Constructor */
   explicit ContentTooLargeException(const std::string &what,
                                     const std::string reply_text,
-                                    boost::uint16_t class_id,
-                                    boost::uint16_t method_id) throw()
+                                    uint16_t class_id,
+                                    uint16_t method_id) throw()
       : ChannelException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -459,15 +459,15 @@ class SIMPLEAMQPCLIENT_EXPORT ContentTooLargeException
 class SIMPLEAMQPCLIENT_EXPORT NoRouteException : public ChannelException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
   /** Constructor */
   explicit NoRouteException(const std::string &what,
                             const std::string reply_text,
-                            boost::uint16_t class_id,
-                            boost::uint16_t method_id) throw()
+                            uint16_t class_id,
+                            uint16_t method_id) throw()
       : ChannelException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -478,15 +478,15 @@ class SIMPLEAMQPCLIENT_EXPORT NoRouteException : public ChannelException {
 class SIMPLEAMQPCLIENT_EXPORT NoConsumersException : public ChannelException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
   /** Constructor */
   explicit NoConsumersException(const std::string &what,
                                 const std::string reply_text,
-                                boost::uint16_t class_id,
-                                boost::uint16_t method_id) throw()
+                                uint16_t class_id,
+                                uint16_t method_id) throw()
       : ChannelException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -496,15 +496,15 @@ class SIMPLEAMQPCLIENT_EXPORT NoConsumersException : public ChannelException {
 class SIMPLEAMQPCLIENT_EXPORT AccessRefusedException : public ChannelException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
   /** Constructor */
   explicit AccessRefusedException(const std::string &what,
                                   const std::string reply_text,
-                                  boost::uint16_t class_id,
-                                  boost::uint16_t method_id) throw()
+                                  uint16_t class_id,
+                                  uint16_t method_id) throw()
       : ChannelException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -514,15 +514,15 @@ class SIMPLEAMQPCLIENT_EXPORT AccessRefusedException : public ChannelException {
 class SIMPLEAMQPCLIENT_EXPORT NotFoundException : public ChannelException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
   /** Constructor */
   explicit NotFoundException(const std::string &what,
                              const std::string reply_text,
-                             boost::uint16_t class_id,
-                             boost::uint16_t method_id) throw()
+                             uint16_t class_id,
+                             uint16_t method_id) throw()
       : ChannelException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -533,15 +533,15 @@ class SIMPLEAMQPCLIENT_EXPORT ResourceLockedException
     : public ChannelException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
   /** Constructor */
   explicit ResourceLockedException(const std::string &what,
                                    const std::string reply_text,
-                                   boost::uint16_t class_id,
-                                   boost::uint16_t method_id) throw()
+                                   uint16_t class_id,
+                                   uint16_t method_id) throw()
       : ChannelException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 /**
@@ -552,15 +552,15 @@ class SIMPLEAMQPCLIENT_EXPORT PreconditionFailedException
     : public ChannelException {
  public:
   /** reply code */
-  static const boost::uint16_t REPLY_CODE;
+  static const uint16_t REPLY_CODE;
   /** Constructor */
   explicit PreconditionFailedException(const std::string &what,
                                        const std::string reply_text,
-                                       boost::uint16_t class_id,
-                                       boost::uint16_t method_id) throw()
+                                       uint16_t class_id,
+                                       uint16_t method_id) throw()
       : ChannelException(what, reply_text, class_id, method_id) {}
 
-  virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
+  virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
 };
 
 }  // namespace AmqpClient
diff --git a/src/SimpleAmqpClient/AmqpResponseLibraryException.h b/src/SimpleAmqpClient/AmqpResponseLibraryException.h
index c76f127..4ec935a 100644
--- a/src/SimpleAmqpClient/AmqpResponseLibraryException.h
+++ b/src/SimpleAmqpClient/AmqpResponseLibraryException.h
@@ -28,7 +28,7 @@
  * ***** END LICENSE BLOCK *****
  */
 
-#include <boost/cstdint.hpp>
+#include <cstdint>
 #include <stdexcept>
 #include <string>
 
diff --git a/src/SimpleAmqpClient/BasicMessage.h b/src/SimpleAmqpClient/BasicMessage.h
index ffa8789..9d8f772 100644
--- a/src/SimpleAmqpClient/BasicMessage.h
+++ b/src/SimpleAmqpClient/BasicMessage.h
@@ -28,11 +28,9 @@
  * ***** END LICENSE BLOCK *****
  */
 
-#include <boost/cstdint.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/scoped_ptr.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/utility.hpp>
+#include <cstdint>
+#include <memory>
+
 #include <string>
 
 #include "SimpleAmqpClient/Table.h"
@@ -51,10 +49,10 @@ namespace AmqpClient {
 /**
  * An AMQP BasicMessage
  */
-class SIMPLEAMQPCLIENT_EXPORT BasicMessage : boost::noncopyable {
+class SIMPLEAMQPCLIENT_EXPORT BasicMessage  {
  public:
   /// A shared pointer to BasicMessage
-  typedef boost::shared_ptr<BasicMessage> ptr_t;
+  typedef std::shared_ptr<BasicMessage> ptr_t;
 
   /// With durable queues, messages can be requested to persist or not
   enum delivery_mode_t {
@@ -66,7 +64,7 @@ class SIMPLEAMQPCLIENT_EXPORT BasicMessage : boost::noncopyable {
   /**
    * Create a new empty BasicMessage object
    */
-  static ptr_t Create() { return boost::make_shared<BasicMessage>(); }
+  static ptr_t Create() { return std::make_shared<BasicMessage>(); }
 
   /**
    * Create a new BasicMessage object with given body
@@ -75,7 +73,7 @@ class SIMPLEAMQPCLIENT_EXPORT BasicMessage : boost::noncopyable {
    * @returns a new BasicMessage object
    */
   static ptr_t Create(const std::string& body) {
-    return boost::make_shared<BasicMessage>(body);
+    return std::make_shared<BasicMessage>(body);
   }
 
   /// Construct empty BasicMessage
@@ -154,11 +152,11 @@ class SIMPLEAMQPCLIENT_EXPORT BasicMessage : boost::noncopyable {
   /**
    * Gets the priority property
    */
-  boost::uint8_t Priority() const;
+  uint8_t Priority() const;
   /**
    * Sets the priority property
    */
-  void Priority(boost::uint8_t priority);
+  void Priority(uint8_t priority);
   /**
    * Determines whether the priority property is set
    */
@@ -239,11 +237,11 @@ class SIMPLEAMQPCLIENT_EXPORT BasicMessage : boost::noncopyable {
   /**
    * Gets the timestamp property
    */
-  boost::uint64_t Timestamp() const;
+  uint64_t Timestamp() const;
   /**
    * Sets the timestamp property
    */
-  void Timestamp(boost::uint64_t timestamp);
+  void Timestamp(uint64_t timestamp);
   /**
    * Determines whether the timestamp property is set
    */
@@ -342,7 +340,7 @@ class SIMPLEAMQPCLIENT_EXPORT BasicMessage : boost::noncopyable {
  protected:
   struct Impl;
   /// PIMPL idiom
-  boost::scoped_ptr<Impl> m_impl;
+  std::unique_ptr<Impl> m_impl;
 };
 
 }  // namespace AmqpClient
diff --git a/src/SimpleAmqpClient/Bytes.h b/src/SimpleAmqpClient/Bytes.h
index 8f35177..a39ce59 100644
--- a/src/SimpleAmqpClient/Bytes.h
+++ b/src/SimpleAmqpClient/Bytes.h
@@ -2,7 +2,7 @@
 #define SIMPLEAMQPCLIENT_BYTES_H
 
 #include <amqp.h>
-#include <boost/utility/string_ref.hpp>
+#include <string_view>
 
 #include <string>
 
@@ -15,7 +15,7 @@ amqp_bytes_t StringToBytes(const std::string& str) {
   return ret;
 }
 
-amqp_bytes_t StringRefToBytes(boost::string_ref str) {
+amqp_bytes_t StringRefToBytes(std::string_view str) {
   amqp_bytes_t ret;
   ret.bytes = reinterpret_cast<void*>(const_cast<char*>(str.data()));
   ret.len = str.length();
diff --git a/src/SimpleAmqpClient/Channel.h b/src/SimpleAmqpClient/Channel.h
index ee65bef..3249c98 100644
--- a/src/SimpleAmqpClient/Channel.h
+++ b/src/SimpleAmqpClient/Channel.h
@@ -28,14 +28,12 @@
  * ***** END LICENSE BLOCK *****
  */
 
-#include <boost/cstdint.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/optional.hpp>
-#include <boost/scoped_ptr.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/utility.hpp>
-#include <boost/utility/string_ref.hpp>
-#include <boost/variant.hpp>
+#include <cstdint>
+#include <memory>
+#include <optional>
+
+#include <string_view>
+#include <variant>
 #include <string>
 #include <vector>
 
@@ -59,10 +57,10 @@ namespace AmqpClient {
  *
  * Represents a logical AMQP channel multiplexed over a connection
  */
-class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
+class SIMPLEAMQPCLIENT_EXPORT Channel  {
  public:
   /// a `shared_ptr` to Channel
-  typedef boost::shared_ptr<Channel> ptr_t;
+  typedef std::shared_ptr<Channel> ptr_t;
 
   static const std::string
       EXCHANGE_TYPE_DIRECT;  ///< `"direct"` string constant
@@ -109,9 +107,9 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
     int port;           ///< Port to connect to, default is 5672.
     int frame_max;      ///< Max frame size in bytes. Default 128KB.
     /// One of BasicAuth or ExternalSaslAuth is required.
-    boost::variant<BasicAuth, ExternalSaslAuth> auth;
+    std::variant<BasicAuth, ExternalSaslAuth> auth;
     /// Connect using TLS/SSL when set, otherwise use an unencrypted channel.
-    boost::optional<TLSParams> tls_params;
+    std::optional<TLSParams> tls_params;
 
     /**
      * Create an OpenOpts struct from a URI.
@@ -351,7 +349,7 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
    * @param exchange_name the name of the exchange to check for.
    * @returns true if the exchange exists on the broker, false otherwise.
    */
-  bool CheckExchangeExists(boost::string_ref exchange_name);
+  bool CheckExchangeExists(std::string_view exchange_name);
 
   /**
    * Declares an exchange
@@ -454,7 +452,7 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
    * @param queue_name the name of the exchange to check for.
    * @returns true if the exchange exists on the broker, false otherwise.
    */
-  bool CheckQueueExists(boost::string_ref queue_name);
+  bool CheckQueueExists(std::string_view queue_name);
 
   /**
    * Declare a queue
@@ -527,8 +525,8 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
    * broker is asked to create a unique queue by not providing a queue name.
    */
   std::string DeclareQueueWithCounts(const std::string &queue_name,
-                                     boost::uint32_t &message_count,
-                                     boost::uint32_t &consumer_count,
+                                     uint32_t &message_count,
+                                     uint32_t &consumer_count,
                                      bool passive = false, bool durable = false,
                                      bool exclusive = true,
                                      bool auto_delete = true);
@@ -558,8 +556,8 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
    * broker is asked to create a unique queue by not providing a queue name.
    */
   std::string DeclareQueueWithCounts(const std::string &queue_name,
-                                     boost::uint32_t &message_count,
-                                     boost::uint32_t &consumer_count,
+                                     uint32_t &message_count,
+                                     uint32_t &consumer_count,
                                      bool passive, bool durable, bool exclusive,
                                      bool auto_delete, const Table &arguments);
 
@@ -772,7 +770,7 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
                            const std::string &consumer_tag = "",
                            bool no_local = true, bool no_ack = true,
                            bool exclusive = true,
-                           boost::uint16_t message_prefetch_count = 1);
+                           uint16_t message_prefetch_count = 1);
 
   /**
    * Starts consuming Basic messages on a queue
@@ -800,7 +798,7 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
   std::string BasicConsume(const std::string &queue,
                            const std::string &consumer_tag, bool no_local,
                            bool no_ack, bool exclusive,
-                           boost::uint16_t message_prefetch_count,
+                           uint16_t message_prefetch_count,
                            const Table &arguments);
 
   /**
@@ -816,7 +814,7 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
    * broker will deliver. A value of 0 means no limit.
    */
   void BasicQos(const std::string &consumer_tag,
-                boost::uint16_t message_prefetch_count);
+                uint16_t message_prefetch_count);
 
   /**
    * Cancels a previously created Consumer
@@ -934,7 +932,7 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
                                         bool sasl_external);
 
   /// PIMPL idiom
-  boost::scoped_ptr<ChannelImpl> m_impl;
+  std::unique_ptr<ChannelImpl> m_impl;
 };
 
 }  // namespace AmqpClient
diff --git a/src/SimpleAmqpClient/ChannelImpl.h b/src/SimpleAmqpClient/ChannelImpl.h
index 62af935..2964ae0 100644
--- a/src/SimpleAmqpClient/ChannelImpl.h
+++ b/src/SimpleAmqpClient/ChannelImpl.h
@@ -1,3 +1,4 @@
+#include <algorithm>
 #ifndef SIMPLEAMQPCLIENT_CHANNELIMPL_H
 #define SIMPLEAMQPCLIENT_CHANNELIMPL_H
 /*
@@ -32,7 +33,7 @@
 #include <amqp.h>
 #include <amqp_framing.h>
 
-#include <boost/array.hpp>
+#include <array>
 
 #include "SimpleAmqpClient/AmqpException.h"
 #include "SimpleAmqpClient/BasicMessage.h"
@@ -41,15 +42,15 @@
 #include "SimpleAmqpClient/Envelope.h"
 #include "SimpleAmqpClient/MessageReturnedException.h"
 #define BOOST_BIND_GLOBAL_PLACEHOLDERS
-#include <boost/bind.hpp>
-#include <boost/chrono.hpp>
-#include <boost/noncopyable.hpp>
+#include <functional>
+#include <chrono>
+
 #include <map>
 #include <vector>
 
 namespace AmqpClient {
 
-class Channel::ChannelImpl : boost::noncopyable {
+class Channel::ChannelImpl  {
  public:
   ChannelImpl();
   virtual ~ChannelImpl();
@@ -67,7 +68,7 @@ class Channel::ChannelImpl : boost::noncopyable {
   bool IsChannelOpen(amqp_channel_t channel);
 
   bool GetNextFrameFromBroker(amqp_frame_t &frame,
-                              boost::chrono::microseconds timeout);
+                              std::chrono::microseconds timeout);
 
   bool CheckForQueuedMessageOnChannel(amqp_channel_t message_on_channel) const;
   void AddToFrameQueue(const amqp_frame_t &frame);
@@ -75,12 +76,12 @@ class Channel::ChannelImpl : boost::noncopyable {
   template <class ChannelListType>
   bool GetNextFrameFromBrokerOnChannel(const ChannelListType channels,
                                        amqp_frame_t &frame_out,
-                                       boost::chrono::microseconds timeout =
-                                           boost::chrono::microseconds::max()) {
-    boost::chrono::steady_clock::time_point end_point;
-    boost::chrono::microseconds timeout_left = timeout;
-    if (timeout != boost::chrono::microseconds::max()) {
-      end_point = boost::chrono::steady_clock::now() + timeout;
+                                       std::chrono::microseconds timeout =
+                                           std::chrono::microseconds::max()) {
+    std::chrono::steady_clock::time_point end_point;
+    std::chrono::microseconds timeout_left = timeout;
+    if (timeout != std::chrono::microseconds::max()) {
+      end_point = std::chrono::steady_clock::now() + timeout;
     }
 
     amqp_frame_t frame;
@@ -104,14 +105,14 @@ class Channel::ChannelImpl : boost::noncopyable {
         AddToFrameQueue(frame);
       }
 
-      if (timeout != boost::chrono::microseconds::max()) {
-        boost::chrono::steady_clock::time_point now =
-            boost::chrono::steady_clock::now();
+      if (timeout != std::chrono::microseconds::max()) {
+        std::chrono::steady_clock::time_point now =
+            std::chrono::steady_clock::now();
         if (now >= end_point) {
           return false;
         }
         timeout_left =
-            boost::chrono::duration_cast<boost::chrono::microseconds>(
+            std::chrono::duration_cast<std::chrono::microseconds>(
                 end_point - now);
       }
     }
@@ -120,7 +121,7 @@ class Channel::ChannelImpl : boost::noncopyable {
 
   bool GetNextFrameOnChannel(
       amqp_channel_t channel, amqp_frame_t &frame,
-      boost::chrono::microseconds timeout = boost::chrono::microseconds::max());
+      std::chrono::microseconds timeout = std::chrono::microseconds::max());
 
   static bool is_on_channel(const amqp_frame_t frame, amqp_channel_t channel) {
     return channel == frame.channel;
@@ -154,14 +155,14 @@ class Channel::ChannelImpl : boost::noncopyable {
   template <class ChannelListType, class ResponseListType>
   bool GetMethodOnChannel(const ChannelListType channels, amqp_frame_t &frame,
                           const ResponseListType &expected_responses,
-                          boost::chrono::microseconds timeout =
-                              boost::chrono::microseconds::max()) {
+                          std::chrono::microseconds timeout =
+                              std::chrono::microseconds::max()) {
     frame_queue_t::iterator desired_frame = std::find_if(
         m_frame_queue.begin(), m_frame_queue.end(),
-        boost::bind(
+        std::bind(
             &ChannelImpl::is_expected_method_on_channel<ChannelListType,
                                                         ResponseListType>,
-            _1, channels, expected_responses));
+            std::placeholders::_1, channels, expected_responses));
 
     if (m_frame_queue.end() != desired_frame) {
       frame = *desired_frame;
@@ -169,10 +170,10 @@ class Channel::ChannelImpl : boost::noncopyable {
       return true;
     }
 
-    boost::chrono::steady_clock::time_point end_point;
-    boost::chrono::microseconds timeout_left = timeout;
-    if (timeout != boost::chrono::microseconds::max()) {
-      end_point = boost::chrono::steady_clock::now() + timeout;
+    std::chrono::steady_clock::time_point end_point;
+    std::chrono::microseconds timeout_left = timeout;
+    if (timeout != std::chrono::microseconds::max()) {
+      end_point = std::chrono::steady_clock::now() + timeout;
     }
 
     amqp_frame_t incoming_frame;
@@ -196,14 +197,14 @@ class Channel::ChannelImpl : boost::noncopyable {
       }
       m_frame_queue.push_back(incoming_frame);
 
-      if (timeout != boost::chrono::microseconds::max()) {
-        boost::chrono::steady_clock::time_point now =
-            boost::chrono::steady_clock::now();
+      if (timeout != std::chrono::microseconds::max()) {
+        std::chrono::steady_clock::time_point now =
+            std::chrono::steady_clock::now();
         if (now >= end_point) {
           return false;
         }
         timeout_left =
-            boost::chrono::duration_cast<boost::chrono::microseconds>(
+            std::chrono::duration_cast<std::chrono::microseconds>(
                 end_point - now);
       }
     }
@@ -211,20 +212,20 @@ class Channel::ChannelImpl : boost::noncopyable {
   }
 
   template <class ResponseListType>
-  amqp_frame_t DoRpcOnChannel(amqp_channel_t channel, boost::uint32_t method_id,
+  amqp_frame_t DoRpcOnChannel(amqp_channel_t channel, uint32_t method_id,
                               void *decoded,
                               const ResponseListType &expected_responses) {
     CheckForError(amqp_send_method(m_connection, channel, method_id, decoded));
 
     amqp_frame_t response;
-    boost::array<amqp_channel_t, 1> channels = {{channel}};
+    std::array<amqp_channel_t, 1> channels = {{channel}};
 
     GetMethodOnChannel(channels, response, expected_responses);
     return response;
   }
 
   template <class ResponseListType>
-  amqp_frame_t DoRpc(boost::uint32_t method_id, void *decoded,
+  amqp_frame_t DoRpc(uint32_t method_id, void *decoded,
                      const ResponseListType &expected_responses) {
     amqp_channel_t channel = GetChannel();
     amqp_frame_t ret =
@@ -245,7 +246,7 @@ class Channel::ChannelImpl : boost::noncopyable {
                                Envelope::ptr_t &message, int timeout) {
     envelope_list_t::iterator it = std::find_if(
         m_delivered_messages.begin(), m_delivered_messages.end(),
-        boost::bind(ChannelImpl::envelope_on_channel<ChannelListType>, _1,
+        std::bind(ChannelImpl::envelope_on_channel<ChannelListType>, std::placeholders::_1,
                     channels));
 
     if (it != m_delivered_messages.end()) {
@@ -260,12 +261,12 @@ class Channel::ChannelImpl : boost::noncopyable {
   template <class ChannelListType>
   bool ConsumeMessageOnChannelInner(const ChannelListType channels,
                                     Envelope::ptr_t &message, int timeout) {
-    const boost::array<boost::uint32_t, 2> DELIVER_OR_CANCEL = {
+    const std::array<uint32_t, 2> DELIVER_OR_CANCEL = {
         {AMQP_BASIC_DELIVER_METHOD, AMQP_BASIC_CANCEL_METHOD}};
 
-    boost::chrono::microseconds real_timeout =
-        (timeout >= 0 ? boost::chrono::milliseconds(timeout)
-                      : boost::chrono::microseconds::max());
+    std::chrono::microseconds real_timeout =
+        (timeout >= 0 ? std::chrono::milliseconds(timeout)
+                      : std::chrono::microseconds::max());
 
     amqp_frame_t deliver;
     if (!GetMethodOnChannel(channels, deliver, DELIVER_OR_CANCEL,
@@ -298,7 +299,7 @@ class Channel::ChannelImpl : boost::noncopyable {
     const std::string in_consumer_tag(
         (char *)deliver_method->consumer_tag.bytes,
         deliver_method->consumer_tag.len);
-    const boost::uint64_t delivery_tag = deliver_method->delivery_tag;
+    const uint64_t delivery_tag = deliver_method->delivery_tag;
     const bool redelivered = (deliver_method->redelivered == 0 ? false : true);
     MaybeReleaseBuffersOnChannel(deliver.channel);
 
@@ -343,7 +344,7 @@ class Channel::ChannelImpl : boost::noncopyable {
   amqp_connection_state_t m_connection;
 
  private:
-  static boost::uint32_t ComputeBrokerVersion(
+  static uint32_t ComputeBrokerVersion(
       const amqp_connection_state_t state);
 
   frame_queue_t m_frame_queue;
@@ -358,7 +359,7 @@ class Channel::ChannelImpl : boost::noncopyable {
   typedef std::vector<channel_state_t> channel_state_list_t;
 
   channel_state_list_t m_channels;
-  boost::uint32_t m_brokerVersion;
+  uint32_t m_brokerVersion;
   // A channel that is likely to be an CS_Open state
   amqp_channel_t m_last_used_channel;
 
diff --git a/src/SimpleAmqpClient/Envelope.h b/src/SimpleAmqpClient/Envelope.h
index b112e30..b1d16e9 100644
--- a/src/SimpleAmqpClient/Envelope.h
+++ b/src/SimpleAmqpClient/Envelope.h
@@ -28,10 +28,9 @@
  * ***** END LICENSE BLOCK *****
  */
 
-#include <boost/cstdint.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/shared_ptr.hpp>
+#include <cstdint>
+#include <memory>
+
 #include <string>
 
 #include "SimpleAmqpClient/BasicMessage.h"
@@ -50,10 +49,10 @@ namespace AmqpClient {
 /**
  * A "message envelope" object containing the message body and delivery metadata
  */
-class SIMPLEAMQPCLIENT_EXPORT Envelope : boost::noncopyable {
+class SIMPLEAMQPCLIENT_EXPORT Envelope  {
  public:
   /// a `shared_ptr` pointer to Envelope
-  typedef boost::shared_ptr<Envelope> ptr_t;
+  typedef std::shared_ptr<Envelope> ptr_t;
 
   /**
    * Creates an new envelope object
@@ -66,15 +65,15 @@ class SIMPLEAMQPCLIENT_EXPORT Envelope : boost::noncopyable {
    * result of a redelivery
    * @param routing_key the routing key that the message was published with
    * @param delivery_channel channel ID of the delivery (see DeliveryInfo)
-   * @returns a boost::shared_ptr to an envelope object
+   * @returns a std::shared_ptr to an envelope object
    */
   static ptr_t Create(const BasicMessage::ptr_t message,
                       const std::string &consumer_tag,
-                      const boost::uint64_t delivery_tag,
+                      const uint64_t delivery_tag,
                       const std::string &exchange, bool redelivered,
                       const std::string &routing_key,
-                      const boost::uint16_t delivery_channel) {
-    return boost::make_shared<Envelope>(message, consumer_tag, delivery_tag,
+                      const uint16_t delivery_channel) {
+    return std::make_shared<Envelope>(message, consumer_tag, delivery_tag,
                                         exchange, redelivered, routing_key,
                                         delivery_channel);
   }
@@ -93,10 +92,10 @@ class SIMPLEAMQPCLIENT_EXPORT Envelope : boost::noncopyable {
    */
   explicit Envelope(const BasicMessage::ptr_t message,
                     const std::string &consumer_tag,
-                    const boost::uint64_t delivery_tag,
+                    const uint64_t delivery_tag,
                     const std::string &exchange, bool redelivered,
                     const std::string &routing_key,
-                    const boost::uint16_t delivery_channel);
+                    const uint16_t delivery_channel);
 
  public:
   /**
@@ -127,7 +126,7 @@ class SIMPLEAMQPCLIENT_EXPORT Envelope : boost::noncopyable {
    *
    * @returns the delivery tag for a message
    */
-  inline boost::uint64_t DeliveryTag() const { return m_deliveryTag; }
+  inline uint64_t DeliveryTag() const { return m_deliveryTag; }
 
   /**
    * Get the name of the exchange that the message was published to
@@ -159,7 +158,7 @@ class SIMPLEAMQPCLIENT_EXPORT Envelope : boost::noncopyable {
   /**
    * Get the delivery channel
    */
-  inline boost::uint16_t DeliveryChannel() const { return m_deliveryChannel; }
+  inline uint16_t DeliveryChannel() const { return m_deliveryChannel; }
 
   /**
    * A POD carrier of delivery-tag
@@ -176,9 +175,9 @@ class SIMPLEAMQPCLIENT_EXPORT Envelope : boost::noncopyable {
   struct DeliveryInfo {
     /// A delivery tag, assigned by the broker to identify this delivery within
     /// a channel
-    boost::uint64_t delivery_tag;
+    uint64_t delivery_tag;
     /// An ID of the delivery channel
-    boost::uint16_t delivery_channel;
+    uint16_t delivery_channel;
   };
 
   /**
@@ -195,11 +194,11 @@ class SIMPLEAMQPCLIENT_EXPORT Envelope : boost::noncopyable {
  private:
   const BasicMessage::ptr_t m_message;
   const std::string m_consumerTag;
-  const boost::uint64_t m_deliveryTag;
+  const uint64_t m_deliveryTag;
   const std::string m_exchange;
   const bool m_redelivered;
   const std::string m_routingKey;
-  const boost::uint16_t m_deliveryChannel;
+  const uint16_t m_deliveryChannel;
 };
 
 }  // namespace AmqpClient
diff --git a/src/SimpleAmqpClient/MessageRejectedException.h b/src/SimpleAmqpClient/MessageRejectedException.h
index 8d4f8b4..460b777 100644
--- a/src/SimpleAmqpClient/MessageRejectedException.h
+++ b/src/SimpleAmqpClient/MessageRejectedException.h
@@ -28,8 +28,9 @@
  * ***** END LICENSE BLOCK *****
  */
 
-#include <boost/cstdint.hpp>
-#include <boost/lexical_cast.hpp>
+#include <cstdint>
+#include <string>
+#include <stdexcept>
 #include <stdexcept>
 
 #include "SimpleAmqpClient/BasicMessage.h"
@@ -51,7 +52,7 @@ class SIMPLEAMQPCLIENT_EXPORT MessageRejectedException
   MessageRejectedException(uint64_t delivery_tag)
       : std::runtime_error(
             std::string("Message rejected: ")
-                .append(boost::lexical_cast<std::string>(delivery_tag))),
+                .append(std::to_string(delivery_tag))),
         m_delivery_tag(delivery_tag) {}
 
   /// `delivery_tag` getter
diff --git a/src/SimpleAmqpClient/MessageReturnedException.h b/src/SimpleAmqpClient/MessageReturnedException.h
index 1b67272..1d6fe0c 100644
--- a/src/SimpleAmqpClient/MessageReturnedException.h
+++ b/src/SimpleAmqpClient/MessageReturnedException.h
@@ -28,7 +28,7 @@
  * ***** END LICENSE BLOCK *****
  */
 
-#include <boost/cstdint.hpp>
+#include <cstdint>
 #include <stdexcept>
 
 #include "SimpleAmqpClient/BasicMessage.h"
@@ -49,7 +49,7 @@ class SIMPLEAMQPCLIENT_EXPORT MessageReturnedException
  public:
   /// Constructor.
   explicit MessageReturnedException(BasicMessage::ptr_t message,
-                                    boost::uint32_t reply_code,
+                                    uint32_t reply_code,
                                     const std::string &reply_text,
                                     const std::string &exchange,
                                     const std::string &routing_key) throw();
@@ -59,7 +59,7 @@ class SIMPLEAMQPCLIENT_EXPORT MessageReturnedException
   /// `message` getter
   BasicMessage::ptr_t message() const throw() { return m_message; }
   /// `reply_code` getter
-  boost::uint32_t reply_code() const throw() { return m_reply_code; }
+  uint32_t reply_code() const throw() { return m_reply_code; }
   /// `reply_text` getter
   std::string reply_text() const throw() { return m_reply_text; }
   /// Exchange name getter
@@ -69,7 +69,7 @@ class SIMPLEAMQPCLIENT_EXPORT MessageReturnedException
 
  private:
   BasicMessage::ptr_t m_message;
-  boost::uint32_t m_reply_code;
+  uint32_t m_reply_code;
   std::string m_reply_text;
   std::string m_exchange;
   std::string m_routing_key;
diff --git a/src/SimpleAmqpClient/Table.h b/src/SimpleAmqpClient/Table.h
index ee41af8..b02d6d7 100644
--- a/src/SimpleAmqpClient/Table.h
+++ b/src/SimpleAmqpClient/Table.h
@@ -1,3 +1,4 @@
+#include <variant>
 #ifndef SIMPLEAMQPCLIENT_TABLE_H
 #define SIMPLEAMQPCLIENT_TABLE_H
 /*
@@ -28,8 +29,8 @@
  * ***** END LICENSE BLOCK *****
  */
 
-#include <boost/cstdint.hpp>
-#include <boost/scoped_ptr.hpp>
+#include <cstdint>
+#include <memory>
 #include <ctime>
 #include <map>
 #include <string>
@@ -119,42 +120,42 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
    *
    * @param [in] value the value
    */
-  TableValue(boost::uint8_t value);
+  TableValue(uint8_t value);
 
   /**
    * Construct a 1-byte signed integer value
    *
    * @param [in] value the value
    */
-  TableValue(boost::int8_t value);
+  TableValue(int8_t value);
 
   /**
    * Construct a 2-byte unsigned integer value
    *
    * @param [in] value the value
    */
-  TableValue(boost::uint16_t value);
+  TableValue(uint16_t value);
 
   /**
    * Construct a 2-byte signed integer value
    *
    * @param [in] value the value
    */
-  TableValue(boost::int16_t value);
+  TableValue(int16_t value);
 
   /**
    * Construct a 4-byte unsigned integer value
    *
    * @param [in] value the value
    */
-  TableValue(boost::uint32_t value);
+  TableValue(uint32_t value);
 
   /**
    * Construct a 4-byte signed integer value
    *
    * @param [in] value the value
    */
-  TableValue(boost::int32_t value);
+  TableValue(int32_t value);
 
  private:
   /**
@@ -163,7 +164,7 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
    * RabbitMQ does not support unsigned 64-bit values in tables,
    * however, timestamps are used for this.
    */
-  TableValue(boost::uint64_t value);
+  TableValue(uint64_t value);
 
  public:
   /**
@@ -180,7 +181,7 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
    *
    * @param [in] value the value
    */
-  TableValue(boost::int64_t value);
+  TableValue(int64_t value);
 
   /**
    * Construct a single-precision floating point value
@@ -266,49 +267,49 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
    *
    * @returns the value if its a VT_uint8 type, 0 otherwise
    */
-  boost::uint8_t GetUint8() const;
+  uint8_t GetUint8() const;
 
   /**
    * Get the int8 value
    *
    * @returns the value if its a VT_int8 type, 0 otherwise
    */
-  boost::int8_t GetInt8() const;
+  int8_t GetInt8() const;
 
   /**
    * Get the uint16 value
    *
    * @returns the value if its a VT_uint16 type, 0 otherwise
    */
-  boost::uint16_t GetUint16() const;
+  uint16_t GetUint16() const;
 
   /**
    * Get the int16 value
    *
    * @returns the value if its a VT_int16 type, 0 otherwise
    */
-  boost::int16_t GetInt16() const;
+  int16_t GetInt16() const;
 
   /**
    * Get the uint32 value
    *
    * @returns the value if its a VT_uint32 type, 0 otherwise
    */
-  boost::uint32_t GetUint32() const;
+  uint32_t GetUint32() const;
 
   /**
    * Get the int32 value
    *
    * @returns the value if its a VT_int32 type, 0 otherwise
    */
-  boost::int32_t GetInt32() const;
+  int32_t GetInt32() const;
 
   /**
    * Get the uint64 value
    *
    * @returns the value if its a VT_uint64 type, 0 otherwise
    */
-  boost::uint64_t GetUint64() const;
+  uint64_t GetUint64() const;
 
   /**
    * Get the timestamp value
@@ -322,7 +323,7 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
    *
    * @returns the value if its a VT_int64 type, 0 otherwise
    */
-  boost::int64_t GetInt64() const;
+  int64_t GetInt64() const;
 
   /**
    * Get an integral number
@@ -334,7 +335,7 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
    * @returns an integer number if the ValueType is VT_uint8, VT_int8,
    * VT_uint16, VT_int16, VT_uint32, VT_int32,or VT_int64 type, 0 otherwise.
    */
-  boost::int64_t GetInteger() const;
+  int64_t GetInteger() const;
 
   /**
    * Get a float value
@@ -395,42 +396,42 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
    *
    * @param [in] value the value
    */
-  void Set(boost::uint8_t value);
+  void Set(uint8_t value);
 
   /**
    * Set the value as a int8_t
    *
    * @param [in] value the value
    */
-  void Set(boost::int8_t value);
+  void Set(int8_t value);
 
   /**
    * Set the value as a uint16_t
    *
    * @param [in] value the value
    */
-  void Set(boost::uint16_t value);
+  void Set(uint16_t value);
 
   /**
    * Set the value as a int16_t
    *
    * @param [in] value the value
    */
-  void Set(boost::int16_t value);
+  void Set(int16_t value);
 
   /**
    * Set the value as a uint32_t
    *
    * @param [in] value the value
    */
-  void Set(boost::uint32_t value);
+  void Set(uint32_t value);
 
   /**
    * Set the value as a int32_t
    *
    * @param [in] value the value
    */
-  void Set(boost::int32_t value);
+  void Set(int32_t value);
 
   /**
    * Set the value as a timestamp.
@@ -444,7 +445,7 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
    *
    * @param [in] value the value
    */
-  void Set(boost::int64_t value);
+  void Set(int64_t value);
 
   /**
    * Set the value as a float
@@ -489,7 +490,7 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
   void Set(const Table &value);
 
  private:
-  boost::scoped_ptr<Detail::TableValueImpl> m_impl;
+  std::unique_ptr<Detail::TableValueImpl> m_impl;
 };
 
 }  // namespace AmqpClient
diff --git a/src/SimpleAmqpClient/TableImpl.h b/src/SimpleAmqpClient/TableImpl.h
index b72bc66..9b20de4 100644
--- a/src/SimpleAmqpClient/TableImpl.h
+++ b/src/SimpleAmqpClient/TableImpl.h
@@ -30,9 +30,9 @@
 
 #include <amqp.h>
 
-#include <boost/cstdint.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/variant/variant.hpp>
+#include <cstdint>
+#include <memory>
+#include <variant>
 #include <ctime>
 #include <string>
 #include <vector>
@@ -42,7 +42,7 @@
 namespace AmqpClient {
 namespace Detail {
 
-typedef boost::shared_ptr<amqp_pool_t> amqp_pool_ptr_t;
+typedef std::shared_ptr<amqp_pool_t> amqp_pool_ptr_t;
 
 struct void_t {};
 
@@ -50,10 +50,10 @@ inline bool operator==(const void_t &, const void_t &) { return true; }
 
 typedef std::vector<TableValue> array_t;
 
-typedef boost::variant<void_t, bool, boost::int8_t, boost::int16_t,
-                       boost::int32_t, boost::int64_t, float, double,
-                       std::string, array_t, Table, boost::uint8_t,
-                       boost::uint16_t, boost::uint32_t, boost::uint64_t>
+typedef std::variant<void_t, bool, int8_t, int16_t,
+                       int32_t, int64_t, float, double,
+                       std::string, array_t, Table, uint8_t,
+                       uint16_t, uint32_t, uint64_t>
     value_t;
 
 class TableValueImpl {
@@ -81,22 +81,21 @@ class TableValueImpl {
                                       amqp_pool_t &pool);
 
  public:
-  class generate_field_value
-      : public boost::static_visitor<amqp_field_value_t> {
+  class generate_field_value {
    public:
     explicit generate_field_value(amqp_pool_t &p) : pool(p) {}
     virtual ~generate_field_value() {}
 
     amqp_field_value_t operator()(const void_t) const;
     amqp_field_value_t operator()(const bool value) const;
-    amqp_field_value_t operator()(const boost::uint8_t value) const;
-    amqp_field_value_t operator()(const boost::int8_t value) const;
-    amqp_field_value_t operator()(const boost::uint16_t value) const;
-    amqp_field_value_t operator()(const boost::int16_t value) const;
-    amqp_field_value_t operator()(const boost::uint32_t value) const;
-    amqp_field_value_t operator()(const boost::int32_t value) const;
-    amqp_field_value_t operator()(const boost::uint64_t value) const;
-    amqp_field_value_t operator()(const boost::int64_t value) const;
+    amqp_field_value_t operator()(const uint8_t value) const;
+    amqp_field_value_t operator()(const int8_t value) const;
+    amqp_field_value_t operator()(const uint16_t value) const;
+    amqp_field_value_t operator()(const int16_t value) const;
+    amqp_field_value_t operator()(const uint32_t value) const;
+    amqp_field_value_t operator()(const int32_t value) const;
+    amqp_field_value_t operator()(const uint64_t value) const;
+    amqp_field_value_t operator()(const int64_t value) const;
     amqp_field_value_t operator()(const float value) const;
     amqp_field_value_t operator()(const double value) const;
     amqp_field_value_t operator()(const std::string &value) const;
diff --git a/src/Table.cpp b/src/Table.cpp
index c28033f..ec90ed6 100644
--- a/src/Table.cpp
+++ b/src/Table.cpp
@@ -29,8 +29,8 @@
 #include "SimpleAmqpClient/Table.h"
 
 #include <algorithm>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/variant/get.hpp>
+#include <type_traits>
+#include <variant>
 #include <ctime>
 #include <iterator>
 #include <limits>
@@ -45,32 +45,32 @@ TableValue::TableValue()
 TableValue::TableValue(bool value)
     : m_impl(new Detail::TableValueImpl(value)) {}
 
-TableValue::TableValue(boost::uint8_t value)
+TableValue::TableValue(uint8_t value)
     : m_impl(new Detail::TableValueImpl(value)) {}
 
-TableValue::TableValue(boost::int8_t value)
+TableValue::TableValue(int8_t value)
     : m_impl(new Detail::TableValueImpl(value)) {}
 
-TableValue::TableValue(boost::uint16_t value)
+TableValue::TableValue(uint16_t value)
     : m_impl(new Detail::TableValueImpl(value)) {}
 
-TableValue::TableValue(boost::int16_t value)
+TableValue::TableValue(int16_t value)
     : m_impl(new Detail::TableValueImpl(value)) {}
 
-TableValue::TableValue(boost::uint32_t value)
+TableValue::TableValue(uint32_t value)
     : m_impl(new Detail::TableValueImpl(value)) {}
 
-TableValue::TableValue(boost::int32_t value)
+TableValue::TableValue(int32_t value)
     : m_impl(new Detail::TableValueImpl(value)) {}
 
-TableValue::TableValue(boost::uint64_t value)
+TableValue::TableValue(uint64_t value)
     : m_impl(new Detail::TableValueImpl(value)) {}
 
 TableValue TableValue::Timestamp(std::time_t ts) {
-  return TableValue(static_cast<boost::uint64_t>(ts));
+  return TableValue(static_cast<uint64_t>(ts));
 }
 
-TableValue::TableValue(boost::int64_t value)
+TableValue::TableValue(int64_t value)
     : m_impl(new Detail::TableValueImpl(value)) {}
 
 TableValue::TableValue(float value)
@@ -134,45 +134,45 @@ bool TableValue::operator!=(const TableValue &l) const {
 TableValue::~TableValue() {}
 
 TableValue::ValueType TableValue::GetType() const {
-  return static_cast<ValueType>(m_impl->m_value.which());
+  return static_cast<ValueType>(m_impl->m_value.index());
 }
 
-bool TableValue::GetBool() const { return boost::get<bool>(m_impl->m_value); }
+bool TableValue::GetBool() const { return std::get<bool>(m_impl->m_value); }
 
-boost::uint8_t TableValue::GetUint8() const {
-  return boost::get<boost::uint8_t>(m_impl->m_value);
+uint8_t TableValue::GetUint8() const {
+  return std::get<uint8_t>(m_impl->m_value);
 }
 
-boost::int8_t TableValue::GetInt8() const {
-  return boost::get<boost::int8_t>(m_impl->m_value);
+int8_t TableValue::GetInt8() const {
+  return std::get<int8_t>(m_impl->m_value);
 }
 
-boost::uint16_t TableValue::GetUint16() const {
-  return boost::get<boost::uint16_t>(m_impl->m_value);
+uint16_t TableValue::GetUint16() const {
+  return std::get<uint16_t>(m_impl->m_value);
 }
 
-boost::int16_t TableValue::GetInt16() const {
-  return boost::get<boost::int16_t>(m_impl->m_value);
+int16_t TableValue::GetInt16() const {
+  return std::get<int16_t>(m_impl->m_value);
 }
 
-boost::uint32_t TableValue::GetUint32() const {
-  return boost::get<boost::uint32_t>(m_impl->m_value);
+uint32_t TableValue::GetUint32() const {
+  return std::get<uint32_t>(m_impl->m_value);
 }
 
-boost::int32_t TableValue::GetInt32() const {
-  return boost::get<boost::int32_t>(m_impl->m_value);
+int32_t TableValue::GetInt32() const {
+  return std::get<int32_t>(m_impl->m_value);
 }
 
 std::time_t TableValue::GetTimestamp() const {
-  return static_cast<std::time_t>(boost::get<boost::uint64_t>(m_impl->m_value));
+  return static_cast<std::time_t>(std::get<uint64_t>(m_impl->m_value));
 }
 
-boost::int64_t TableValue::GetInt64() const {
-  return boost::get<boost::int64_t>(m_impl->m_value);
+int64_t TableValue::GetInt64() const {
+  return std::get<int64_t>(m_impl->m_value);
 }
 
-boost::int64_t TableValue::GetInteger() const {
-  switch (m_impl->m_value.which()) {
+int64_t TableValue::GetInteger() const {
+  switch (m_impl->m_value.index()) {
     case VT_uint8:
       return GetUint8();
     case VT_int8:
@@ -188,62 +188,62 @@ boost::int64_t TableValue::GetInteger() const {
     case VT_int64:
       return GetInt64();
     default:
-      throw boost::bad_get();
+      throw std::bad_variant_access();
   }
 }
 
 float TableValue::GetFloat() const {
-  return boost::get<float>(m_impl->m_value);
+  return std::get<float>(m_impl->m_value);
 }
 
 double TableValue::GetDouble() const {
-  return boost::get<double>(m_impl->m_value);
+  return std::get<double>(m_impl->m_value);
 }
 
 double TableValue::GetReal() const {
-  switch (m_impl->m_value.which()) {
+  switch (m_impl->m_value.index()) {
     case VT_float:
       return GetFloat();
     case VT_double:
       return GetDouble();
     default:
-      throw boost::bad_get();
+      throw std::bad_variant_access();
   }
 }
 
 std::string TableValue::GetString() const {
-  return boost::get<std::string>(m_impl->m_value);
+  return std::get<std::string>(m_impl->m_value);
 }
 
 std::vector<TableValue> TableValue::GetArray() const {
-  return boost::get<Detail::array_t>(m_impl->m_value);
+  return std::get<Detail::array_t>(m_impl->m_value);
 }
 
 Table TableValue::GetTable() const {
-  return boost::get<Table>(m_impl->m_value);
+  return std::get<Table>(m_impl->m_value);
 }
 
 void TableValue::Set() { m_impl->m_value = Detail::void_t(); }
 
 void TableValue::Set(bool value) { m_impl->m_value = value; }
 
-void TableValue::Set(boost::uint8_t value) { m_impl->m_value = value; }
+void TableValue::Set(uint8_t value) { m_impl->m_value = value; }
 
-void TableValue::Set(boost::int8_t value) { m_impl->m_value = value; }
+void TableValue::Set(int8_t value) { m_impl->m_value = value; }
 
-void TableValue::Set(boost::uint16_t value) { m_impl->m_value = value; }
+void TableValue::Set(uint16_t value) { m_impl->m_value = value; }
 
-void TableValue::Set(boost::int16_t value) { m_impl->m_value = value; }
+void TableValue::Set(int16_t value) { m_impl->m_value = value; }
 
-void TableValue::Set(boost::uint32_t value) { m_impl->m_value = value; }
+void TableValue::Set(uint32_t value) { m_impl->m_value = value; }
 
-void TableValue::Set(boost::int32_t value) { m_impl->m_value = value; }
+void TableValue::Set(int32_t value) { m_impl->m_value = value; }
 
 void TableValue::SetTimestamp(std::time_t value) {
-  m_impl->m_value = static_cast<boost::uint64_t>(value);
+  m_impl->m_value = static_cast<uint64_t>(value);
 }
 
-void TableValue::Set(boost::int64_t value) { m_impl->m_value = value; }
+void TableValue::Set(int64_t value) { m_impl->m_value = value; }
 
 void TableValue::Set(float value) { m_impl->m_value = value; }
 
diff --git a/src/TableImpl.cpp b/src/TableImpl.cpp
index a861060..9b05549 100644
--- a/src/TableImpl.cpp
+++ b/src/TableImpl.cpp
@@ -36,9 +36,8 @@
 #include <string.h>
 
 #include <algorithm>
-#include <boost/foreach.hpp>
-#include <boost/variant/apply_visitor.hpp>
-#include <boost/variant/static_visitor.hpp>
+
+#include <variant>
 #include <new>
 
 #ifdef _MSC_VER
@@ -64,7 +63,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
 }
 
 amqp_field_value_t TableValueImpl::generate_field_value::operator()(
-    const boost::uint8_t value) const {
+    const uint8_t value) const {
   amqp_field_value_t v;
   v.kind = AMQP_FIELD_KIND_U8;
   v.value.u8 = value;
@@ -72,7 +71,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
 }
 
 amqp_field_value_t TableValueImpl::generate_field_value::operator()(
-    const boost::int8_t value) const {
+    const int8_t value) const {
   amqp_field_value_t v;
   v.kind = AMQP_FIELD_KIND_I8;
   v.value.i8 = value;
@@ -80,7 +79,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
 }
 
 amqp_field_value_t TableValueImpl::generate_field_value::operator()(
-    const boost::uint16_t value) const {
+    const uint16_t value) const {
   amqp_field_value_t v;
   v.kind = AMQP_FIELD_KIND_U16;
   v.value.u16 = value;
@@ -88,7 +87,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
 }
 
 amqp_field_value_t TableValueImpl::generate_field_value::operator()(
-    const boost::int16_t value) const {
+    const int16_t value) const {
   amqp_field_value_t v;
   v.kind = AMQP_FIELD_KIND_I16;
   v.value.i16 = value;
@@ -96,7 +95,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
 }
 
 amqp_field_value_t TableValueImpl::generate_field_value::operator()(
-    const boost::uint32_t value) const {
+    const uint32_t value) const {
   amqp_field_value_t v;
   v.kind = AMQP_FIELD_KIND_U32;
   v.value.u32 = value;
@@ -104,7 +103,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
 }
 
 amqp_field_value_t TableValueImpl::generate_field_value::operator()(
-    const boost::int32_t value) const {
+    const int32_t value) const {
   amqp_field_value_t v;
   v.kind = AMQP_FIELD_KIND_I32;
   v.value.i32 = value;
@@ -112,7 +111,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
 }
 
 amqp_field_value_t TableValueImpl::generate_field_value::operator()(
-    const boost::uint64_t value) const {
+    const uint64_t value) const {
   amqp_field_value_t v;
   v.kind = AMQP_FIELD_KIND_TIMESTAMP;
   v.value.u64 = value;
@@ -120,7 +119,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
 }
 
 amqp_field_value_t TableValueImpl::generate_field_value::operator()(
-    const boost::int64_t value) const {
+    const int64_t value) const {
   amqp_field_value_t v;
   v.kind = AMQP_FIELD_KIND_I64;
   v.value.i64 = value;
@@ -167,7 +166,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
   for (array_t::const_iterator it = value.begin(); it != value.end();
        ++it, ++output_iterator) {
     *output_iterator =
-        boost::apply_visitor(generate_field_value(pool), it->m_impl->m_value);
+        std::visit(generate_field_value(pool), it->m_impl->m_value);
   }
   return v;
 }
@@ -191,7 +190,7 @@ amqp_table_t TableValueImpl::CreateAmqpTable(const Table &table,
     return AMQP_EMPTY_TABLE;
   }
 
-  pool = boost::shared_ptr<amqp_pool_t>(new amqp_pool_t, free_pool);
+  pool = std::shared_ptr<amqp_pool_t>(new amqp_pool_t, free_pool);
   init_amqp_pool(pool.get(), 1024);
 
   return CreateAmqpTableInner(table, *pool.get());
@@ -221,7 +220,7 @@ amqp_table_t TableValueImpl::CreateAmqpTableInner(const Table &table,
 
     std::copy(it->first.begin(), it->first.end(), (char *)output_it->key.bytes);
 
-    output_it->value = boost::apply_visitor(
+    output_it->value = std::visit(
         TableValueImpl::generate_field_value(pool), it->second.m_impl->m_value);
   }
 
@@ -297,7 +296,7 @@ amqp_table_t TableValueImpl::CopyTable(const amqp_table_t &table,
     return AMQP_EMPTY_TABLE;
   }
 
-  pool = boost::shared_ptr<amqp_pool_t>(new amqp_pool_t, free_pool);
+  pool = std::shared_ptr<amqp_pool_t>(new amqp_pool_t, free_pool);
   init_amqp_pool(pool.get(), 1024);
 
   return CopyTableInner(table, *pool.get());
diff --git a/testing/CMakeLists.txt b/testing/CMakeLists.txt
index 2cd5815..f4f8b35 100644
--- a/testing/CMakeLists.txt
+++ b/testing/CMakeLists.txt
@@ -1,4 +1,3 @@
-include_directories(BEFORE SYSTEM ${gtest_SOURCE_DIR}/include)
 include_directories(../src)
 
 add_executable(test_api
@@ -15,5 +14,9 @@ add_executable(test_api
     test_ack.cpp
     test_nack.cpp
     )
-target_link_libraries(test_api SimpleAmqpClient gtest gtest_main)
+target_link_libraries(test_api SimpleAmqpClient xgoogletest::xgoogletest)
 add_test(test_api test_api)
+
+if(MSVC)
+    target_compile_options(test_api PRIVATE /utf-8)
+endif()
diff --git a/testing/connected_test.h b/testing/connected_test.h
index e1a0c51..6c610d0 100644
--- a/testing/connected_test.h
+++ b/testing/connected_test.h
@@ -51,7 +51,7 @@ class connected_test : public ::testing::Test {
     if (NULL != host) {
       return std::string(host);
     }
-    return std::string("");
+    return std::string("127.0.0.1");
   }
 };
 
diff --git a/testing/test_consume.cpp b/testing/test_consume.cpp
index 507a624..7f5bd3c 100644
--- a/testing/test_consume.cpp
+++ b/testing/test_consume.cpp
@@ -1,3 +1,4 @@
+#include <functional>
 /*
  * ***** BEGIN LICENSE BLOCK *****
  * Version: MIT
diff --git a/testing/test_message.cpp b/testing/test_message.cpp
index 54e57a2..77c7fc5 100644
--- a/testing/test_message.cpp
+++ b/testing/test_message.cpp
@@ -29,7 +29,7 @@
 #include <amqp.h>
 
 #include <algorithm>
-#include <boost/array.hpp>
+#include <array>
 #include <iostream>
 
 #include "connected_test.h"
@@ -103,13 +103,13 @@ TEST(basic_message, initial_message_replace2) {
 }
 
 TEST(basic_message, embedded_nulls) {
-  const boost::array<char, 7> message_data = {
+  const std::array<char, 7> message_data = {
       {'a', 'b', 'c', 0, '1', '2', '3'}};
   const std::string body(message_data.data(), message_data.size());
   BasicMessage::ptr_t message = BasicMessage::Create(body);
   EXPECT_EQ(body, message->Body());
 
-  const boost::array<char, 7> message_data2 = {
+  const std::array<char, 7> message_data2 = {
       {'1', '2', '3', 0, 'a', 'b', 'c'}};
   const std::string body2(message_data2.data(), message_data2.size());
   message->Body(body2);
diff --git a/testing/test_queue.cpp b/testing/test_queue.cpp
index f157697..079bafe 100644
--- a/testing/test_queue.cpp
+++ b/testing/test_queue.cpp
@@ -83,8 +83,8 @@ TEST_F(connected_test, queue_declare_notautodelete) {
 }
 
 TEST_F(connected_test, queue_declare_counts) {
-  boost::uint32_t message_count = 123;
-  boost::uint32_t consumer_count = 123;
+  uint32_t message_count = 123;
+  uint32_t consumer_count = 123;
 
   std::string queue = channel->DeclareQueueWithCounts(
       "queue_declare_counts", message_count, consumer_count);
@@ -110,8 +110,8 @@ TEST_F(connected_test, queue_declare_counts) {
 }
 
 TEST_F(connected_test, queue_declare_counts_table) {
-  boost::uint32_t message_count = 123;
-  boost::uint32_t consumer_count = 123;
+  uint32_t message_count = 123;
+  uint32_t consumer_count = 123;
 
   Table qTable;
 
diff --git a/testing/test_table.cpp b/testing/test_table.cpp
index 5f02adf..708e7c6 100644
--- a/testing/test_table.cpp
+++ b/testing/test_table.cpp
@@ -27,8 +27,8 @@
  */
 
 #include <algorithm>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/variant/get.hpp>
+#include <type_traits>
+#include <variant>
 #include <ctime>
 
 #include "connected_test.h"
@@ -39,42 +39,42 @@ TEST(table_value, void_value) {
   TableValue value;
   EXPECT_EQ(TableValue::VT_void, value.GetType());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetInteger(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInteger(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 
   value.Set();
   EXPECT_EQ(TableValue::VT_void, value.GetType());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetInteger(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInteger(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 }
 
 TEST(table_value, bool_value) {
@@ -85,311 +85,311 @@ TEST(table_value, bool_value) {
   EXPECT_EQ(TableValue::VT_bool, value.GetType());
 
   EXPECT_EQ(v1, value.GetBool());
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetInteger(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInteger(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 
   value.Set(v2);
   EXPECT_EQ(TableValue::VT_bool, value.GetType());
 
   EXPECT_EQ(v2, value.GetBool());
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetInteger(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInteger(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 }
 
 TEST(table_value, uint8_value) {
-  boost::uint8_t v1 = 1;
-  boost::uint8_t v2 = 2;
+  uint8_t v1 = 1;
+  uint8_t v2 = 2;
 
   TableValue value(v1);
   EXPECT_EQ(TableValue::VT_uint8, value.GetType());
   EXPECT_EQ(v1, value.GetUint8());
   EXPECT_EQ(v1, value.GetInteger());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 
   value.Set(v2);
   EXPECT_EQ(TableValue::VT_uint8, value.GetType());
   EXPECT_EQ(v2, value.GetUint8());
   EXPECT_EQ(v2, value.GetInteger());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 }
 
 TEST(table_value, int8_value) {
-  boost::int8_t v1 = 1;
-  boost::int8_t v2 = 2;
+  int8_t v1 = 1;
+  int8_t v2 = 2;
 
   TableValue value(v1);
   EXPECT_EQ(TableValue::VT_int8, value.GetType());
   EXPECT_EQ(v1, value.GetInt8());
   EXPECT_EQ(v1, value.GetInteger());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 
   value.Set(v2);
   EXPECT_EQ(TableValue::VT_int8, value.GetType());
   EXPECT_EQ(v2, value.GetInt8());
   EXPECT_EQ(v2, value.GetInteger());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 }
 
 TEST(table_value, uint16_value) {
-  boost::uint16_t v1 = 1;
-  boost::uint16_t v2 = 2;
+  uint16_t v1 = 1;
+  uint16_t v2 = 2;
 
   TableValue value(v1);
   EXPECT_EQ(TableValue::VT_uint16, value.GetType());
   EXPECT_EQ(v1, value.GetUint16());
   EXPECT_EQ(v1, value.GetInteger());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 
   value.Set(v2);
   EXPECT_EQ(TableValue::VT_uint16, value.GetType());
   EXPECT_EQ(v2, value.GetUint16());
   EXPECT_EQ(v2, value.GetInteger());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 }
 
 TEST(table_value, int16_value) {
-  boost::int16_t v1 = 1;
-  boost::int16_t v2 = 2;
+  int16_t v1 = 1;
+  int16_t v2 = 2;
 
   TableValue value(v1);
   EXPECT_EQ(TableValue::VT_int16, value.GetType());
   EXPECT_EQ(v1, value.GetInt16());
   EXPECT_EQ(v1, value.GetInteger());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 
   value.Set(v2);
   EXPECT_EQ(TableValue::VT_int16, value.GetType());
   EXPECT_EQ(v2, value.GetInt16());
   EXPECT_EQ(v2, value.GetInteger());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 }
 
 TEST(table_value, uint32_value) {
-  boost::uint32_t v1 = 1;
-  boost::uint32_t v2 = 2;
+  uint32_t v1 = 1;
+  uint32_t v2 = 2;
 
   TableValue value(v1);
   EXPECT_EQ(TableValue::VT_uint32, value.GetType());
   EXPECT_EQ(v1, value.GetUint32());
   EXPECT_EQ(v1, value.GetInteger());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 
   value.Set(v2);
   EXPECT_EQ(TableValue::VT_uint32, value.GetType());
   EXPECT_EQ(v2, value.GetUint32());
   EXPECT_EQ(v2, value.GetInteger());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 }
 
 TEST(table_value, int32_value) {
-  boost::int32_t v1 = 1;
-  boost::int32_t v2 = 2;
+  int32_t v1 = 1;
+  int32_t v2 = 2;
 
   TableValue value(v1);
   EXPECT_EQ(TableValue::VT_int32, value.GetType());
   EXPECT_EQ(v1, value.GetInt32());
   EXPECT_EQ(v1, value.GetInteger());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 
   value.Set(v2);
   EXPECT_EQ(TableValue::VT_int32, value.GetType());
   EXPECT_EQ(v2, value.GetInt32());
   EXPECT_EQ(v2, value.GetInteger());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 }
 
 TEST(table_value, timestamp_value) {
@@ -400,86 +400,86 @@ TEST(table_value, timestamp_value) {
   EXPECT_EQ(TableValue::VT_timestamp, value.GetType());
   EXPECT_EQ(v1, value.GetTimestamp());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetInteger(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInteger(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 
   value.SetTimestamp(v2);
   EXPECT_EQ(TableValue::VT_timestamp, value.GetType());
   EXPECT_EQ(v2, value.GetTimestamp());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetInteger(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInteger(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 }
 
 TEST(table_value, int64_value) {
-  boost::int64_t v1 = 1;
-  boost::int64_t v2 = 2;
+  int64_t v1 = 1;
+  int64_t v2 = 2;
 
   TableValue value(v1);
   EXPECT_EQ(TableValue::VT_int64, value.GetType());
   EXPECT_EQ(v1, value.GetInt64());
   EXPECT_EQ(v1, value.GetInteger());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 
   value.Set(v2);
   EXPECT_EQ(TableValue::VT_int64, value.GetType());
   EXPECT_EQ(v2, value.GetInt64());
   EXPECT_EQ(v2, value.GetInteger());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 }
 
 TEST(table_value, float_value) {
@@ -491,40 +491,40 @@ TEST(table_value, float_value) {
   EXPECT_EQ(v1, value.GetFloat());
   EXPECT_EQ(v1, value.GetReal());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetInteger(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInteger(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 
   value.Set(v2);
   EXPECT_EQ(TableValue::VT_float, value.GetType());
   EXPECT_EQ(v2, value.GetFloat());
   EXPECT_EQ(v2, value.GetReal());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetInteger(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInteger(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 }
 
 TEST(table_value, double_value) {
@@ -536,40 +536,40 @@ TEST(table_value, double_value) {
   EXPECT_EQ(v1, value.GetDouble());
   EXPECT_EQ(v1, value.GetReal());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetInteger(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInteger(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 
   value.Set(v2);
   EXPECT_EQ(TableValue::VT_double, value.GetType());
   EXPECT_EQ(v2, value.GetDouble());
   EXPECT_EQ(v2, value.GetReal());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetInteger(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInteger(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 }
 
 TEST(table_value, string_value) {
@@ -580,41 +580,41 @@ TEST(table_value, string_value) {
   EXPECT_EQ(TableValue::VT_string, value.GetType());
   EXPECT_EQ(v1, value.GetString());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetInteger(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInteger(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 
   value.Set(v2);
   EXPECT_EQ(TableValue::VT_string, value.GetType());
   EXPECT_EQ(v2, value.GetString());
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetInteger(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInteger(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 }
 
 TEST(table_value, array_value) {
@@ -630,21 +630,21 @@ TEST(table_value, array_value) {
   EXPECT_TRUE(v1.size() == v1a.size());
   EXPECT_TRUE(std::equal(v1.begin(), v1.end(), v1a.begin()));
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetInteger(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInteger(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 
   value.Set(v2);
   EXPECT_EQ(TableValue::VT_array, value.GetType());
@@ -652,21 +652,21 @@ TEST(table_value, array_value) {
   EXPECT_TRUE(v2.size() == v2a.size());
   EXPECT_TRUE(std::equal(v2.begin(), v2.end(), v2a.begin()));
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetInteger(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetTable(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInteger(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTable(), std::bad_variant_access);
 }
 
 TEST(table_value, table_value) {
@@ -682,21 +682,21 @@ TEST(table_value, table_value) {
   EXPECT_TRUE(v1.size() == v1a.size());
   EXPECT_TRUE(std::equal(v1.begin(), v1.end(), v1a.begin()));
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetInteger(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInteger(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
 
   value.Set(v2);
   EXPECT_EQ(TableValue::VT_table, value.GetType());
@@ -704,21 +704,21 @@ TEST(table_value, table_value) {
   EXPECT_TRUE(v2.size() == v2a.size());
   EXPECT_TRUE(std::equal(v2.begin(), v2.end(), v2a.begin()));
 
-  EXPECT_THROW(value.GetBool(), boost::bad_get);
-  EXPECT_THROW(value.GetUint8(), boost::bad_get);
-  EXPECT_THROW(value.GetInt8(), boost::bad_get);
-  EXPECT_THROW(value.GetUint16(), boost::bad_get);
-  EXPECT_THROW(value.GetInt16(), boost::bad_get);
-  EXPECT_THROW(value.GetUint32(), boost::bad_get);
-  EXPECT_THROW(value.GetInt32(), boost::bad_get);
-  EXPECT_THROW(value.GetTimestamp(), boost::bad_get);
-  EXPECT_THROW(value.GetInt64(), boost::bad_get);
-  EXPECT_THROW(value.GetInteger(), boost::bad_get);
-  EXPECT_THROW(value.GetFloat(), boost::bad_get);
-  EXPECT_THROW(value.GetDouble(), boost::bad_get);
-  EXPECT_THROW(value.GetReal(), boost::bad_get);
-  EXPECT_THROW(value.GetString(), boost::bad_get);
-  EXPECT_THROW(value.GetArray(), boost::bad_get);
+  EXPECT_THROW(value.GetBool(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt8(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt16(), std::bad_variant_access);
+  EXPECT_THROW(value.GetUint32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt32(), std::bad_variant_access);
+  EXPECT_THROW(value.GetTimestamp(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInt64(), std::bad_variant_access);
+  EXPECT_THROW(value.GetInteger(), std::bad_variant_access);
+  EXPECT_THROW(value.GetFloat(), std::bad_variant_access);
+  EXPECT_THROW(value.GetDouble(), std::bad_variant_access);
+  EXPECT_THROW(value.GetReal(), std::bad_variant_access);
+  EXPECT_THROW(value.GetString(), std::bad_variant_access);
+  EXPECT_THROW(value.GetArray(), std::bad_variant_access);
 }
 
 TEST(table_value, equality) {