diff --git a/CMakeLists.txt b/CMakeLists.txt
index 25d59ffe..888283fb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,15 +18,12 @@ target_link_libraries(boost_dll
     Boost::config
     Boost::core
     Boost::filesystem
-    Boost::function
-    Boost::move
     Boost::predef
     Boost::smart_ptr
     Boost::spirit
     Boost::system
     Boost::throw_exception
     Boost::type_index
-    Boost::type_traits
     Boost::winapi
 )
 
diff --git a/build.jam b/build.jam
index 5e67738b..19c19dd2 100644
--- a/build.jam
+++ b/build.jam
@@ -16,7 +16,6 @@ constant boost_dependencies :
     /boost/system//boost_system
     /boost/throw_exception//boost_throw_exception
     /boost/type_index//boost_type_index
-    /boost/type_traits//boost_type_traits
     /boost/winapi//boost_winapi ;
 
 project /boost/dll
diff --git a/include/boost/dll/detail/aggressive_ptr_cast.hpp b/include/boost/dll/detail/aggressive_ptr_cast.hpp
index 75ddc654..8d0615f5 100644
--- a/include/boost/dll/detail/aggressive_ptr_cast.hpp
+++ b/include/boost/dll/detail/aggressive_ptr_cast.hpp
@@ -13,15 +13,9 @@
 #   pragma once
 #endif
 
-#include <boost/core/addressof.hpp>
-#include <boost/core/enable_if.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_member_pointer.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <boost/type_traits/is_reference.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/type_traits/remove_reference.hpp>
 #include <cstring>              // std::memcpy
+#include <memory>
+#include <type_traits>
 
 #if defined(__GNUC__) && defined(__GNUC_MINOR__) && (__GNUC__ * 100 + __GNUC_MINOR__ > 301)
 #   pragma GCC system_header
@@ -32,16 +26,16 @@ namespace boost { namespace dll { namespace detail {
 // GCC warns when reinterpret_cast between function pointer and object pointer occur.
 // This method suppress the warnings and ensures that such casts are safe.
 template <class To, class From>
-BOOST_FORCEINLINE typename boost::disable_if_c<boost::is_member_pointer<To>::value || boost::is_reference<To>::value || boost::is_member_pointer<From>::value, To>::type
+BOOST_FORCEINLINE typename std::enable_if<!std::is_member_pointer<To>::value && !std::is_reference<To>::value && !std::is_member_pointer<From>::value, To>::type
     aggressive_ptr_cast(From v) noexcept
 {
     static_assert(
-        boost::is_pointer<To>::value && boost::is_pointer<From>::value,
+        std::is_pointer<To>::value && std::is_pointer<From>::value,
         "`agressive_ptr_cast` function must be used only for pointer casting."
     );
 
     static_assert(
-        boost::is_void< typename boost::remove_pointer<To>::type >::value
+        std::is_void< typename std::remove_pointer<To>::type >::value
         || boost::is_void< typename boost::remove_pointer<From>::type >::value,
         "`agressive_ptr_cast` function must be used only for casting to or from void pointers."
     );
@@ -60,25 +54,25 @@ BOOST_FORCEINLINE typename boost::disable_if_c<boost::is_member_pointer<To>::val
 #endif
 
 template <class To, class From>
-BOOST_FORCEINLINE typename boost::disable_if_c<!boost::is_reference<To>::value || boost::is_member_pointer<From>::value, To>::type
+BOOST_FORCEINLINE typename std::enable_if<std::is_reference<To>::value && !std::is_member_pointer<From>::value, To>::type
     aggressive_ptr_cast(From v) noexcept
 {
     static_assert(
-        boost::is_pointer<From>::value,
+        std::is_pointer<From>::value,
         "`agressive_ptr_cast` function must be used only for pointer casting."
     );
 
     static_assert(
-        boost::is_void< typename boost::remove_pointer<From>::type >::value,
+        std::is_void< typename std::remove_pointer<From>::type >::value,
         "`agressive_ptr_cast` function must be used only for casting to or from void pointers."
     );
 
     static_assert(
-        sizeof(v) == sizeof(typename boost::remove_reference<To>::type*),
+        sizeof(v) == sizeof(typename std::remove_reference<To>::type*),
         "Pointer to function and pointer to object differ in size on your platform."
     );
     return static_cast<To>(
-        **reinterpret_cast<typename boost::remove_reference<To>::type**>(
+        **reinterpret_cast<typename std::remove_reference<To>::type**>(
             v
         )
     );
@@ -89,16 +83,16 @@ BOOST_FORCEINLINE typename boost::disable_if_c<!boost::is_reference<To>::value |
 #endif
 
 template <class To, class From>
-BOOST_FORCEINLINE typename boost::disable_if_c<!boost::is_member_pointer<To>::value || boost::is_member_pointer<From>::value, To>::type
+BOOST_FORCEINLINE typename std::enable_if<std::is_member_pointer<To>::value && !std::is_member_pointer<From>::value, To>::type
     aggressive_ptr_cast(From v) noexcept
 {
     static_assert(
-        boost::is_pointer<From>::value,
+        std::is_pointer<From>::value,
         "`agressive_ptr_cast` function must be used only for pointer casting."
     );
 
     static_assert(
-        boost::is_void< typename boost::remove_pointer<From>::type >::value,
+        std::is_void< typename boost::remove_pointer<From>::type >::value,
         "`agressive_ptr_cast` function must be used only for casting to or from void pointers."
     );
 
@@ -108,16 +102,16 @@ BOOST_FORCEINLINE typename boost::disable_if_c<!boost::is_member_pointer<To>::va
 }
 
 template <class To, class From>
-BOOST_FORCEINLINE typename boost::disable_if_c<boost::is_member_pointer<To>::value || !boost::is_member_pointer<From>::value, To>::type
+BOOST_FORCEINLINE typename std::enable_if<!std::is_member_pointer<To>::value && std::is_member_pointer<From>::value, To>::type
     aggressive_ptr_cast(From /* v */) noexcept
 {
     static_assert(
-        boost::is_pointer<To>::value,
+        std::is_pointer<To>::value,
         "`agressive_ptr_cast` function must be used only for pointer casting."
     );
 
     static_assert(
-        boost::is_void< typename boost::remove_pointer<To>::type >::value,
+        std::is_void< typename std::remove_pointer<To>::type >::value,
         "`agressive_ptr_cast` function must be used only for casting to or from void pointers."
     );
 
diff --git a/include/boost/dll/detail/demangling/itanium.hpp b/include/boost/dll/detail/demangling/itanium.hpp
index 236477f1..3db5ac53 100644
--- a/include/boost/dll/detail/demangling/itanium.hpp
+++ b/include/boost/dll/detail/demangling/itanium.hpp
@@ -8,13 +8,9 @@
 #define BOOST_DLL_DETAIL_DEMANGLING_ITANIUM_HPP_
 
 #include <boost/dll/detail/demangling/mangled_storage_base.hpp>
+
 #include <iterator>
 #include <algorithm>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_volatile.hpp>
-#include <boost/type_traits/is_rvalue_reference.hpp>
-#include <boost/type_traits/is_lvalue_reference.hpp>
-#include <boost/type_traits/function_traits.hpp>
 
 
 namespace boost { namespace dll { namespace detail {
diff --git a/include/boost/dll/detail/demangling/mangled_storage_base.hpp b/include/boost/dll/detail/demangling/mangled_storage_base.hpp
index d1241a00..32d0a7cc 100644
--- a/include/boost/dll/detail/demangling/mangled_storage_base.hpp
+++ b/include/boost/dll/detail/demangling/mangled_storage_base.hpp
@@ -10,10 +10,12 @@
 #include <vector>
 #include <string>
 #include <map>
+#include <type_traits>
+
 #include <boost/dll/detail/demangling/demangle_symbol.hpp>
 #include <boost/dll/library_info.hpp>
 #include <boost/type_index/ctti_type_index.hpp>
-#include <boost/type_traits/remove_reference.hpp>
+
 
 namespace boost { namespace dll { namespace detail {
 
diff --git a/include/boost/dll/detail/demangling/msvc.hpp b/include/boost/dll/detail/demangling/msvc.hpp
index 6f98e780..638b1fe5 100644
--- a/include/boost/dll/detail/demangling/msvc.hpp
+++ b/include/boost/dll/detail/demangling/msvc.hpp
@@ -10,12 +10,6 @@
 #include <boost/dll/detail/demangling/mangled_storage_base.hpp>
 #include <iterator>
 #include <algorithm>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_volatile.hpp>
-#include <boost/type_traits/is_lvalue_reference.hpp>
-#include <boost/type_traits/is_rvalue_reference.hpp>
-#include <boost/type_traits/function_traits.hpp>
-#include <boost/type_traits/remove_reference.hpp>
 
 #include <boost/spirit/home/x3.hpp>
 
diff --git a/include/boost/dll/detail/import_mangled_helpers.hpp b/include/boost/dll/detail/import_mangled_helpers.hpp
index 9838f818..c1c77813 100644
--- a/include/boost/dll/detail/import_mangled_helpers.hpp
+++ b/include/boost/dll/detail/import_mangled_helpers.hpp
@@ -8,11 +8,7 @@
 #define BOOST_DLL_DETAIL_IMPORT_MANGLED_HELPERS_HPP_
 
 
-#include <boost/type_traits/conditional.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_class.hpp>
-#include <boost/type_traits/is_function.hpp>
-#include <boost/type_traits/remove_cv.hpp>
+#include <type_traits>
 
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
@@ -34,9 +30,9 @@ struct push_front<Value, sequence<Args...>>
 
 template<class Lhs, class Rhs>
 struct unqalified_is_same :
-        boost::is_same<
-            typename boost::remove_cv<Lhs>::type,
-            typename boost::remove_cv<Rhs>::type
+        std::is_same<
+            typename std::remove_cv<Lhs>::type,
+            typename std::remove_cv<Rhs>::type
         >
 {
 };
@@ -48,19 +44,19 @@ template<class T> struct is_function_seq;
 
 //type-trait for function overloads
 template<class Class, class...Args> struct is_function_seq<sequence<Class, Args...>>
-            : boost::conditional<
-                boost::is_function<Class>::value,
+            : std::conditional<
+                std::is_function<Class>::value,
                 is_function_seq<sequence<Args...>>,
-                boost::false_type>::type
+                std::false_type>::type
 {};
 
 template<class Class>
-struct is_function_seq<sequence<Class>> : boost::is_function<Class>
+struct is_function_seq<sequence<Class>> : std::is_function<Class>
 {
 };
 
 template<>
-struct is_function_seq<sequence<>> : boost::false_type
+struct is_function_seq<sequence<>> : std::false_type
 {
 };
 
@@ -151,11 +147,11 @@ struct make_mem_fn_seq<T0, T1, T2, Args...>
      * Class, const Class, void(int)//--> ovl class.
      *
      */
-    static_assert(boost::is_object<T0>::value, "");
+    static_assert(std::is_object<T0>::value, "");
     typedef typename make_mem_fn_seq_getter<
            unqalified_is_same<T0, T1>::value, T0, T1, T2>::type mem_fn_type;
 
-    typedef typename boost::conditional<
+    typedef typename std::conditional<
         unqalified_is_same<T0, T1>::value,
         make_mem_fn_seq<T1, Args...>,
         make_mem_fn_seq<T0, T2, Args...>> ::type next;
@@ -203,46 +199,46 @@ struct make_mem_fn_seq<T0, T1, T2, Args...>
 template<class T, class U, class ...Args>
 struct is_mem_fn_seq_impl
 {
-    typedef typename boost::conditional<
-                 boost::is_function<U>::value || boost::dll::experimental::detail::unqalified_is_same<T, U>::value,
+    typedef typename std::conditional<
+                 std::is_function<U>::value || boost::dll::experimental::detail::unqalified_is_same<T, U>::value,
                  typename is_mem_fn_seq_impl<T, Args...>::type,
-                 boost::false_type>::type type;
+                 std::false_type>::type type;
 };
 
 template<class T, class U>
 struct is_mem_fn_seq_impl<T, U>
 {
-    typedef typename boost::conditional<
-                 boost::is_function<U>::value && boost::is_object<T>::value,
-                 boost::true_type, boost::false_type>::type type;
+    typedef typename std::conditional<
+                 std::is_function<U>::value && std::is_object<T>::value,
+                 std::true_type, std::false_type>::type type;
 };
 
 template<class T, class U, class Last>
 struct is_mem_fn_seq_impl<T, U, Last>
 {
-    typedef typename boost::conditional<
-                 (boost::is_function<U>::value || boost::dll::experimental::detail::unqalified_is_same<T, U>::value)
-                 && boost::is_function<Last>::value,
-                 boost::true_type, boost::false_type>::type type;
+    typedef typename std::conditional<
+                 (std::is_function<U>::value || boost::dll::experimental::detail::unqalified_is_same<T, U>::value)
+                 && std::is_function<Last>::value,
+                 std::true_type, std::false_type>::type type;
 };
 
-template<class T> struct is_mem_fn_seq : boost::false_type {};
+template<class T> struct is_mem_fn_seq : std::false_type {};
 
 //If only two arguments are provided at all.
 template<class T, class U>
-struct is_mem_fn_seq<sequence<T, U>> : boost::conditional<
-                 boost::is_object<T>::value && boost::is_function<U>::value,
-                 boost::true_type, boost::false_type>::type
+struct is_mem_fn_seq<sequence<T, U>> : std::conditional<
+                 std::is_object<T>::value && std::is_function<U>::value,
+                 std::true_type, std::false_type>::type
 {
 };
 
 
 template<class T, class Func, class ...Args>
 struct is_mem_fn_seq<sequence<T, Func, Args...>> :
-        boost::conditional<
-            boost::is_class<T>::value && boost::is_function<Func>::value,
+        std::conditional<
+            std::is_class<T>::value && std::is_function<Func>::value,
             typename is_mem_fn_seq_impl<T, Args...>::type,
-            boost::false_type>::type {};
+            std::false_type>::type {};
 
 
 /* ********************************** mem fn sequence tuple ******************************/
diff --git a/include/boost/dll/import.hpp b/include/boost/dll/import.hpp
index 5d953134..0397f787 100644
--- a/include/boost/dll/import.hpp
+++ b/include/boost/dll/import.hpp
@@ -9,12 +9,12 @@
 #define BOOST_DLL_IMPORT_HPP
 
 #include <boost/dll/config.hpp>
-#include <boost/core/addressof.hpp>
-#include <boost/core/enable_if.hpp>
-#include <boost/type_traits/is_object.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/dll/shared_library.hpp>
 
+#include <memory>  // std::addressof
+#include <type_traits>
+
 #ifdef BOOST_HAS_PRAGMA_ONCE
 # pragma once
 #endif
@@ -58,7 +58,7 @@ namespace detail {
 
     template <class T>
     using import_type = typename std::conditional<
-        boost::is_object<T>::value,
+        std::is_object<T>::value,
         boost::shared_ptr<T>,
         boost::dll::detail::library_function<T>
     >::type;
@@ -111,7 +111,7 @@ BOOST_DLL_IMPORT_RESULT_TYPE import_symbol(const boost::dll::fs::path& lib, cons
     using type = boost::dll::detail::import_type<T>;
 
     auto p = boost::make_shared<boost::dll::shared_library>(lib, mode);
-    return type(p, boost::addressof(p->get<T>(name)));
+    return type(p, std::addressof(p->get<T>(name)));
 }
 
 //! \overload boost::dll::import_symbol(const boost::dll::fs::path& lib, const char* name, load_mode::type mode)
@@ -128,7 +128,7 @@ BOOST_DLL_IMPORT_RESULT_TYPE import_symbol(const shared_library& lib, const char
     using type = boost::dll::detail::import_type<T>;
 
     auto p = boost::make_shared<boost::dll::shared_library>(lib);
-    return type(p, boost::addressof(p->get<T>(name)));
+    return type(p, std::addressof(p->get<T>(name)));
 }
 
 //! \overload boost::dll::import_symbol(const boost::dll::fs::path& lib, const char* name, load_mode::type mode)
@@ -145,7 +145,7 @@ BOOST_DLL_IMPORT_RESULT_TYPE import_symbol(shared_library&& lib, const char* nam
     auto p = boost::make_shared<boost::dll::shared_library>(
         std::move(lib)
     );
-    return type(p, boost::addressof(p->get<T>(name)));
+    return type(p, std::addressof(p->get<T>(name)));
 }
 
 //! \overload boost::dll::import_symbol(const boost::dll::fs::path& lib, const char* name, load_mode::type mode)
diff --git a/include/boost/dll/import_mangled.hpp b/include/boost/dll/import_mangled.hpp
index c4dfe18c..1a5e22cf 100644
--- a/include/boost/dll/import_mangled.hpp
+++ b/include/boost/dll/import_mangled.hpp
@@ -21,10 +21,9 @@
 #include <boost/make_shared.hpp>
 #include <boost/dll/smart_library.hpp>
 #include <boost/dll/detail/import_mangled_helpers.hpp>
-#include <boost/core/addressof.hpp>
-#include <boost/core/enable_if.hpp>
-#include <boost/type_traits/conditional.hpp>
-#include <boost/type_traits/is_object.hpp>
+
+#include <memory>  // std::addressof
+#include <type_traits>
 
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
@@ -93,8 +92,8 @@ class mangled_library_mem_fn<Class, sequence<Ts...>> {
 
 
 // simple enough to be here
-template<class Seq>  struct is_variable : boost::false_type {};
-template<typename T> struct is_variable<sequence<T>> : boost::is_object<T> {};
+template<class Seq>  struct is_variable : std::false_type {};
+template<typename T> struct is_variable<sequence<T>> : std::is_object<T> {};
 
 template <class Sequence,
           bool isFunction = is_function_seq<Sequence>::value,
@@ -112,7 +111,7 @@ struct mangled_import_type<sequence<Args...>, true,false,false> //is function
     {
         return type(
                 boost::make_shared<shared_library>(p.shared_lib()),
-                boost::addressof(p.get_function<Args>(name))...);
+                std::addressof(p.get_function<Args>(name))...);
     }
 };
 
@@ -153,7 +152,7 @@ struct mangled_import_type<sequence<T>, false, false, true> //is variable
     {
         return type(
                 boost::make_shared<shared_library>(p.shared_lib()),
-                boost::addressof(p.get_variable<T>(name)));
+                std::addressof(p.get_variable<T>(name)));
     }
 
 };
@@ -281,7 +280,7 @@ BOOST_DLL_MANGLED_IMPORT_RESULT_TYPE import_mangled(const shared_library& lib, c
     typedef typename boost::dll::experimental::detail::mangled_import_type<detail::sequence<Args...>> type;
 
     boost::shared_ptr<boost::dll::experimental::smart_library> p = boost::make_shared<boost::dll::experimental::smart_library>(lib);
-    return type::make(p, name);
+    return type::boostmake(p, name);
 }
 
 //! \overload boost::dll::import(const boost::dll::fs::path& lib, const char* name, load_mode::type mode)
diff --git a/include/boost/dll/library_info.hpp b/include/boost/dll/library_info.hpp
index 95747e0c..d68d7a9a 100644
--- a/include/boost/dll/library_info.hpp
+++ b/include/boost/dll/library_info.hpp
@@ -14,9 +14,9 @@
 #include <boost/predef/os.h>
 #include <boost/predef/architecture.h>
 #include <boost/throw_exception.hpp>
-#include <boost/type_traits/integral_constant.hpp>
 
 #include <fstream>
+#include <type_traits>
 
 #include <boost/dll/detail/pe_info.hpp>
 #include <boost/dll/detail/elf_info.hpp>
@@ -50,15 +50,15 @@ class library_info: private boost::noncopyable {
     } fmt_;
 
     /// @cond
-    inline static void throw_if_in_32bit_impl(boost::true_type /* is_32bit_platform */) {
+    inline static void throw_if_in_32bit_impl(std::true_type /* is_32bit_platform */) {
         boost::throw_exception(std::runtime_error("Not native format: 64bit binary"));
     }
 
-    inline static void throw_if_in_32bit_impl(boost::false_type /* is_32bit_platform */) noexcept {}
+    inline static void throw_if_in_32bit_impl(std::false_type /* is_32bit_platform */) noexcept {}
 
 
     inline static void throw_if_in_32bit() {
-        throw_if_in_32bit_impl( boost::integral_constant<bool, (sizeof(void*) == 4)>() );
+        throw_if_in_32bit_impl( std::integral_constant<bool, (sizeof(void*) == 4)>() );
     }
 
     static void throw_if_in_windows() {
diff --git a/include/boost/dll/shared_library.hpp b/include/boost/dll/shared_library.hpp
index c85a1046..30b44f13 100644
--- a/include/boost/dll/shared_library.hpp
+++ b/include/boost/dll/shared_library.hpp
@@ -16,7 +16,6 @@
 #include <boost/predef/os.h>
 #include <boost/core/enable_if.hpp>
 #include <boost/core/explicit_operator_bool.hpp>
-#include <boost/type_traits/is_member_pointer.hpp>
 #include <boost/dll/detail/system_error.hpp>
 #include <boost/dll/detail/aggressive_ptr_cast.hpp>
 
@@ -26,6 +25,7 @@
 #   include <boost/dll/detail/posix/shared_library_impl.hpp>
 #endif
 
+#include <type_traits>
 #include <utility>  // std::move
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
@@ -341,19 +341,19 @@ class shared_library
     * \throw \forcedlinkfs{system_error} if symbol does not exist or if the DLL/DSO was not loaded.
     */
     template <typename T>
-    inline typename boost::enable_if_c<boost::is_member_pointer<T>::value || boost::is_reference<T>::value, T>::type  get(const std::string& symbol_name) const {
+    inline typename std::enable_if<std::is_member_pointer<T>::value || std::is_reference<T>::value, T>::type  get(const std::string& symbol_name) const {
         return get<T>(symbol_name.c_str());
     }
 
     //! \overload T& get(const std::string& symbol_name) const
     template <typename T>
-    inline typename boost::disable_if_c<boost::is_member_pointer<T>::value || boost::is_reference<T>::value, T&>::type get(const std::string& symbol_name) const {
+    inline typename std::enable_if<!(std::is_member_pointer<T>::value || std::is_reference<T>::value), T&>::type get(const std::string& symbol_name) const {
         return get<T>(symbol_name.c_str());
     }
 
     //! \overload T& get(const std::string& symbol_name) const
     template <typename T>
-    inline typename boost::enable_if_c<boost::is_member_pointer<T>::value || boost::is_reference<T>::value, T>::type get(const char* symbol_name) const {
+    inline typename std::enable_if<std::is_member_pointer<T>::value || std::is_reference<T>::value, T>::type get(const char* symbol_name) const {
         return boost::dll::detail::aggressive_ptr_cast<T>(
             get_void(symbol_name)
         );
@@ -361,7 +361,7 @@ class shared_library
 
     //! \overload T& get(const std::string& symbol_name) const
     template <typename T>
-    inline typename boost::disable_if_c<boost::is_member_pointer<T>::value || boost::is_reference<T>::value, T&>::type get(const char* symbol_name) const {
+    inline typename std::enable_if<!(std::is_member_pointer<T>::value || std::is_reference<T>::value), T&>::type get(const char* symbol_name) const {
         return *boost::dll::detail::aggressive_ptr_cast<T*>(
             get_void(symbol_name)
         );
diff --git a/include/boost/dll/smart_library.hpp b/include/boost/dll/smart_library.hpp
index 12b14bbf..d1c6ae24 100644
--- a/include/boost/dll/smart_library.hpp
+++ b/include/boost/dll/smart_library.hpp
@@ -27,10 +27,8 @@
 #include <boost/dll/detail/get_mem_fn_type.hpp>
 #include <boost/dll/detail/ctor_dtor.hpp>
 #include <boost/dll/detail/type_info.hpp>
-#include <boost/type_traits/is_object.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <boost/type_traits/is_function.hpp>
 
+#include <type_traits>
 #include <utility>  // std::move
 
 namespace boost {
@@ -436,14 +434,14 @@ void get(const smart_library& sm, const std::string &name);
 #endif
 
 template<class T>
-typename boost::enable_if<boost::is_object<T>, T&>::type get(const smart_library& sm, const std::string &name)
+typename std::enable_if<std::is_object<T>::value, T&>::type get(const smart_library& sm, const std::string &name)
 
 {
     return sm.get_variable<T>(name);
 }
 
 template<class T>
-typename boost::enable_if<boost::is_function<T>, T&>::type get(const smart_library& sm, const std::string &name)
+typename std::enable_if<std::is_function<T>::value, T&>::type get(const smart_library& sm, const std::string &name)
 {
     return sm.get_function<T>(name);
 }