diff --git a/lib/cpp/test/AllProtocolTests.tcc b/lib/cpp/test/AllProtocolTests.tcc
index b6df656..a7eab07 100644
--- a/lib/cpp/test/AllProtocolTests.tcc
+++ b/lib/cpp/test/AllProtocolTests.tcc
@@ -28,7 +28,7 @@
 
 #include "GenericHelpers.h"
 
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 using namespace apache::thrift;
 using namespace apache::thrift::protocol;
 using namespace apache::thrift::transport;
diff --git a/lib/cpp/test/Benchmark.cpp b/lib/cpp/test/Benchmark.cpp
index afde7d4..5ff77aa 100644
--- a/lib/cpp/test/Benchmark.cpp
+++ b/lib/cpp/test/Benchmark.cpp
@@ -23,8 +23,8 @@
 #include <iostream>
 #define _USE_MATH_DEFINES
 #include <math.h>
+#include <memory>
 #include "thrift/protocol/TBinaryProtocol.h"
-#include "thrift/stdcxx.h"
 #include "thrift/transport/TBufferTransports.h"
 #include "gen-cpp/DebugProtoTest_types.h"
 
@@ -68,7 +68,7 @@
   ooe.base64 = "\1\2\3\255";
 
   int num = 100000;
-  apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf(new TMemoryBuffer(num*1000));
+  std::shared_ptr<TMemoryBuffer> buf(new TMemoryBuffer(num*1000));
 
   uint8_t* data = NULL;
   uint32_t datasize = 0;
@@ -89,7 +89,7 @@
   buf->getBuffer(&data, &datasize);
 
   {
-    apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+    std::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
     TBinaryProtocolT<TMemoryBuffer> prot(buf2);
     OneOfEach ooe2;
     double elapsed = 0.0;
@@ -117,7 +117,7 @@
 
   {
     OneOfEach ooe2;
-    apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+    std::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
     TBinaryProtocolT<TMemoryBuffer, TNetworkLittleEndian> prot(buf2);
     double elapsed = 0.0;
     Timer timer;
@@ -143,7 +143,7 @@
   }
 
   {
-    apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+    std::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
     TBinaryProtocolT<TMemoryBuffer> prot(buf2);
     OneOfEach ooe2;
     double elapsed = 0.0;
@@ -182,7 +182,7 @@
   buf->getBuffer(&data, &datasize);
 
   {
-    apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+    std::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
     TBinaryProtocolT<TMemoryBuffer> prot(buf2);
     ListDoublePerf listDoublePerf2;
     double elapsed = 0.0;
@@ -206,7 +206,7 @@
 
   {
     ListDoublePerf listDoublePerf2;
-    apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+    std::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
     TBinaryProtocolT<TMemoryBuffer, TNetworkLittleEndian> prot(buf2);
     double elapsed = 0.0;
     Timer timer;
@@ -228,7 +228,7 @@
   }
 
   {
-    apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
+    std::shared_ptr<TMemoryBuffer> buf2(new TMemoryBuffer(data, datasize));
     TBinaryProtocolT<TMemoryBuffer> prot(buf2);
     ListDoublePerf listDoublePerf2;
     double elapsed = 0.0;
diff --git a/lib/cpp/test/DebugProtoTest.cpp b/lib/cpp/test/DebugProtoTest.cpp
index e04600a..060f354 100644
--- a/lib/cpp/test/DebugProtoTest.cpp
+++ b/lib/cpp/test/DebugProtoTest.cpp
@@ -21,14 +21,14 @@
 #include <cmath>
 #include "gen-cpp/DebugProtoTest_types.h"
 #include <thrift/protocol/TDebugProtocol.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 #define BOOST_TEST_MODULE DebugProtoTest
 #include <boost/test/unit_test.hpp>
 
 using namespace thrift::test::debug;
 
-static ::apache::thrift::stdcxx::shared_ptr<OneOfEach> ooe;
+static ::std::shared_ptr<OneOfEach> ooe;
 
 void testCaseSetup_1() {
   ooe.reset(new OneOfEach);
@@ -81,7 +81,7 @@
     "Expected:\n" << expected_result << "\nGotten:\n" << result);
 }
 
-static ::apache::thrift::stdcxx::shared_ptr<Nesting> n;
+static ::std::shared_ptr<Nesting> n;
 
 void testCaseSetup_2() {
   testCaseSetup_1();
@@ -149,7 +149,7 @@
     "Expected:\n" << expected_result << "\nGotten:\n" << result);
 }
 
-static ::apache::thrift::stdcxx::shared_ptr<HolyMoley> hm;
+static ::std::shared_ptr<HolyMoley> hm;
 
 void testCaseSetup_3() {
   testCaseSetup_2();
diff --git a/lib/cpp/test/GenericHelpers.h b/lib/cpp/test/GenericHelpers.h
index e131c42..bcef9f2 100644
--- a/lib/cpp/test/GenericHelpers.h
+++ b/lib/cpp/test/GenericHelpers.h
@@ -21,7 +21,7 @@
 #define _THRIFT_TEST_GENERICHELPERS_H_ 1
 
 #include <thrift/protocol/TProtocol.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/Thrift.h>
 
 /* ClassName Helper for cleaner exceptions */
@@ -63,43 +63,43 @@
 public:
   /* Write functions */
 
-  static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int8_t& val) {
+  static uint32_t write(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int8_t& val) {
     return proto->writeByte(val);
   }
 
-  static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int16_t& val) {
+  static uint32_t write(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int16_t& val) {
     return proto->writeI16(val);
   }
 
-  static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int32_t& val) {
+  static uint32_t write(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int32_t& val) {
     return proto->writeI32(val);
   }
 
-  static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const double& val) {
+  static uint32_t write(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, const double& val) {
     return proto->writeDouble(val);
   }
 
-  static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int64_t& val) {
+  static uint32_t write(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, const int64_t& val) {
     return proto->writeI64(val);
   }
 
-  static uint32_t write(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, const std::string& val) {
+  static uint32_t write(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, const std::string& val) {
     return proto->writeString(val);
   }
 
   /* Read functions */
 
-  static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, int8_t& val) { return proto->readByte(val); }
+  static uint32_t read(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, int8_t& val) { return proto->readByte(val); }
 
-  static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, int16_t& val) { return proto->readI16(val); }
+  static uint32_t read(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, int16_t& val) { return proto->readI16(val); }
 
-  static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, int32_t& val) { return proto->readI32(val); }
+  static uint32_t read(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, int32_t& val) { return proto->readI32(val); }
 
-  static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, int64_t& val) { return proto->readI64(val); }
+  static uint32_t read(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, int64_t& val) { return proto->readI64(val); }
 
-  static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, double& val) { return proto->readDouble(val); }
+  static uint32_t read(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, double& val) { return proto->readDouble(val); }
 
-  static uint32_t read(apache::thrift::stdcxx::shared_ptr<apache::thrift::protocol::TProtocol> proto, std::string& val) {
+  static uint32_t read(std::shared_ptr<apache::thrift::protocol::TProtocol> proto, std::string& val) {
     return proto->readString(val);
   }
 };
diff --git a/lib/cpp/test/JSONProtoTest.cpp b/lib/cpp/test/JSONProtoTest.cpp
index 77bc250..c2ad73e 100644
--- a/lib/cpp/test/JSONProtoTest.cpp
+++ b/lib/cpp/test/JSONProtoTest.cpp
@@ -22,7 +22,7 @@
 #include <iomanip>
 #include <sstream>
 #include <thrift/protocol/TJSONProtocol.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TBufferTransports.h>
 #include "gen-cpp/DebugProtoTest_types.h"
 
@@ -34,7 +34,7 @@
 using apache::thrift::transport::TMemoryBuffer;
 using apache::thrift::protocol::TJSONProtocol;
 
-static stdcxx::shared_ptr<OneOfEach> ooe;
+static std::shared_ptr<OneOfEach> ooe;
 
 void testCaseSetup_1() {
   ooe.reset(new OneOfEach);
@@ -67,7 +67,7 @@
     "Expected:\n" << expected_result << "\nGotten:\n" << result);
 }
 
-static stdcxx::shared_ptr<Nesting> n;
+static std::shared_ptr<Nesting> n;
 
 void testCaseSetup_2() {
   testCaseSetup_1();
@@ -107,7 +107,7 @@
     "Expected:\n" << expected_result << "\nGotten:\n" << result);
 }
 
-static stdcxx::shared_ptr<HolyMoley> hm;
+static std::shared_ptr<HolyMoley> hm;
 
 void testCaseSetup_3() {
   testCaseSetup_2();
@@ -185,8 +185,8 @@
 BOOST_AUTO_TEST_CASE(test_json_proto_4) {
   testCaseSetup_1();
 
-  stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
-  stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+  std::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
+  std::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
 
   ooe->write(proto.get());
   OneOfEach ooe2;
@@ -198,8 +198,8 @@
 BOOST_AUTO_TEST_CASE(test_json_proto_5) {
   testCaseSetup_3();
 
-  stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
-  stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+  std::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
+  std::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
 
   hm->write(proto.get());
   HolyMoley hm2;
@@ -236,8 +236,8 @@
 }
 
 BOOST_AUTO_TEST_CASE(test_json_proto_7) {
-  stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
-  stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+  std::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
+  std::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
 
   Base64 base;
   base.a = 123;
@@ -265,9 +265,9 @@
   "\",3,1,2,3]}}";
 
   const std::size_t bufSiz = strlen(json_string) * sizeof(char);
-  stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
+  std::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
     (uint8_t*)(json_string), static_cast<uint32_t>(bufSiz)));
-  stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+  std::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
 
   OneOfEach ooe2;
 
@@ -294,9 +294,9 @@
   "\",3,1,2,3]}}";
   const char* expected_zomg_unicode = "\xe0\xb8\x81 \xf0\x9d\x94\xbe";
 
-  stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
+  std::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
     (uint8_t*)(json_string), sizeof(json_string)));
-  stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+  std::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
 
   OneOfEach ooe2;
   ooe2.read(proto.get());
@@ -315,9 +315,9 @@
   ":[\"i8\",3,1,2,3]},\"13\":{\"lst\":[\"i16\",3,1,2,3]},\"14\":{\"lst\":[\"i64"
   "\",3,1,2,3]}}";
 
-  stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
+  std::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
     (uint8_t*)(json_string), sizeof(json_string)));
-  stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+  std::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
 
   OneOfEach ooe2;
   BOOST_CHECK_THROW(ooe2.read(proto.get()),
@@ -333,9 +333,9 @@
   ":[\"i8\",3,1,2,3]},\"13\":{\"lst\":[\"i16\",3,1,2,3]},\"14\":{\"lst\":[\"i64"
   "\",3,1,2,3]}}";
 
-  stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
+  std::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer(
     (uint8_t*)(json_string), sizeof(json_string)));
-  stdcxx::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
+  std::shared_ptr<TJSONProtocol> proto(new TJSONProtocol(buffer));
 
   OneOfEach ooe2;
   BOOST_CHECK_THROW(ooe2.read(proto.get()),
diff --git a/lib/cpp/test/OneWayHTTPTest.cpp b/lib/cpp/test/OneWayHTTPTest.cpp
index 3fe63b6..89fa164 100644
--- a/lib/cpp/test/OneWayHTTPTest.cpp
+++ b/lib/cpp/test/OneWayHTTPTest.cpp
@@ -30,7 +30,7 @@
 #include <thrift/transport/THttpClient.h>
 #include <thrift/transport/TServerSocket.h>
 #include <thrift/transport/TSocket.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TBufferTransports.h>
 #include "gen-cpp/OneWayService.h"
 
@@ -54,7 +54,7 @@
 using apache::thrift::transport::TServerSocket;
 using apache::thrift::transport::TSocket;
 using apache::thrift::transport::TTransportException;
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 using std::cout;
 using std::cerr;
 using std::endl;
@@ -138,7 +138,7 @@
 
 class TBlockableBufferedTransport : public TBufferedTransport {
  public:
-  TBlockableBufferedTransport(stdcxx::shared_ptr<TTransport> transport)
+  TBlockableBufferedTransport(std::shared_ptr<TTransport> transport)
     : TBufferedTransport(transport, 10240),
     blocked_(false) {
   }
@@ -176,14 +176,14 @@
 
 BOOST_AUTO_TEST_CASE( JSON_BufferedHTTP )
 {
-  stdcxx::shared_ptr<TServerSocket> ss = stdcxx::make_shared<TServerSocket>(0) ;
+  std::shared_ptr<TServerSocket> ss = std::make_shared<TServerSocket>(0) ;
   TThreadedServer server(
-    stdcxx::make_shared<onewaytest::OneWayServiceProcessorFactory>(stdcxx::make_shared<OneWayServiceCloneFactory>()),
+    std::make_shared<onewaytest::OneWayServiceProcessorFactory>(std::make_shared<OneWayServiceCloneFactory>()),
     ss, //port
-    stdcxx::make_shared<THttpServerTransportFactory>(),
-    stdcxx::make_shared<TJSONProtocolFactory>());
+    std::make_shared<THttpServerTransportFactory>(),
+    std::make_shared<TJSONProtocolFactory>());
 
-  stdcxx::shared_ptr<TServerReadyEventHandler> pEventHandler(new TServerReadyEventHandler) ;
+  std::shared_ptr<TServerReadyEventHandler> pEventHandler(new TServerReadyEventHandler) ;
   server.setServerEventHandler(pEventHandler);
 
 #ifdef ENABLE_STDERR_LOGGING
@@ -205,11 +205,11 @@
 #endif
 
   {
-    stdcxx::shared_ptr<TSocket> socket(new TSocket("localhost", port));
+    std::shared_ptr<TSocket> socket(new TSocket("localhost", port));
     socket->setRecvTimeout(10000) ; // 1000msec should be enough
-    stdcxx::shared_ptr<TBlockableBufferedTransport> blockable_transport(new TBlockableBufferedTransport(socket));
-    stdcxx::shared_ptr<TTransport> transport(new THttpClient(blockable_transport, "localhost", "/service"));
-    stdcxx::shared_ptr<TProtocol> protocol(new TJSONProtocol(transport));
+    std::shared_ptr<TBlockableBufferedTransport> blockable_transport(new TBlockableBufferedTransport(socket));
+    std::shared_ptr<TTransport> transport(new THttpClient(blockable_transport, "localhost", "/service"));
+    std::shared_ptr<TProtocol> protocol(new TJSONProtocol(transport));
     onewaytest::OneWayServiceClient client(protocol);
 
 
diff --git a/lib/cpp/test/OptionalRequiredTest.cpp b/lib/cpp/test/OptionalRequiredTest.cpp
index 55fe249..4c43546 100644
--- a/lib/cpp/test/OptionalRequiredTest.cpp
+++ b/lib/cpp/test/OptionalRequiredTest.cpp
@@ -40,7 +40,7 @@
 void trywrite(const Struct& s, bool should_work) {
   bool worked;
   try {
-    TBinaryProtocol protocol(stdcxx::shared_ptr<TTransport>(new TMemoryBuffer));
+    TBinaryProtocol protocol(std::shared_ptr<TTransport>(new TMemoryBuffer));
     s.write(&protocol);
     worked = true;
   } catch (TProtocolException & ex) {
@@ -52,7 +52,7 @@
 
 template <typename Struct1, typename Struct2>
 void write_to_read(const Struct1& w, Struct2& r) {
-  TBinaryProtocol protocol(stdcxx::shared_ptr<TTransport>(new TMemoryBuffer));
+  TBinaryProtocol protocol(std::shared_ptr<TTransport>(new TMemoryBuffer));
   w.write(&protocol);
   r.read(&protocol);
 }
@@ -303,7 +303,7 @@
   o1.im_big.push_back(mymap);
   BOOST_CHECK(o1 == o2);
 
-  TBinaryProtocol protocol(stdcxx::shared_ptr<TTransport>(new TMemoryBuffer));
+  TBinaryProtocol protocol(std::shared_ptr<TTransport>(new TMemoryBuffer));
   o1.write(&protocol);
 
   o1.im_big.push_back(mymap);
diff --git a/lib/cpp/test/RecursiveTest.cpp b/lib/cpp/test/RecursiveTest.cpp
index ce5569b..15f234c 100644
--- a/lib/cpp/test/RecursiveTest.cpp
+++ b/lib/cpp/test/RecursiveTest.cpp
@@ -23,7 +23,7 @@
 
 #include "gen-cpp/Recursive_types.h"
 #include <thrift/protocol/TBinaryProtocol.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TBufferTransports.h>
 
 #define BOOST_TEST_MODULE RecursiveTest
@@ -31,7 +31,7 @@
 
 using apache::thrift::transport::TMemoryBuffer;
 using apache::thrift::protocol::TBinaryProtocol;
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 
 BOOST_AUTO_TEST_CASE(test_recursive_1) {
   shared_ptr<TMemoryBuffer> buf(new TMemoryBuffer());
diff --git a/lib/cpp/test/SecurityTest.cpp b/lib/cpp/test/SecurityTest.cpp
index 51ee427..982a4f3 100644
--- a/lib/cpp/test/SecurityTest.cpp
+++ b/lib/cpp/test/SecurityTest.cpp
@@ -23,7 +23,7 @@
 #include <boost/foreach.hpp>
 #include <boost/format.hpp>
 #include <boost/thread.hpp>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TSSLServerSocket.h>
 #include <thrift/transport/TSSLSocket.h>
 #include <thrift/transport/TTransport.h>
@@ -40,8 +40,8 @@
 using apache::thrift::transport::TTransportException;
 using apache::thrift::transport::TTransportFactory;
 
-using apache::thrift::stdcxx::bind;
-using apache::thrift::stdcxx::shared_ptr;
+using std::bind;
+using std::shared_ptr;
 
 boost::filesystem::path keyDir;
 boost::filesystem::path certFile(const std::string& filename)
diff --git a/lib/cpp/test/SpecializationTest.cpp b/lib/cpp/test/SpecializationTest.cpp
index a060b4f..008837d 100644
--- a/lib/cpp/test/SpecializationTest.cpp
+++ b/lib/cpp/test/SpecializationTest.cpp
@@ -82,8 +82,8 @@
   stage2.back().message = "nevermore";
   hm.bonks["poe"] = stage2;
 
-  apache::thrift::stdcxx::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
-  apache::thrift::stdcxx::shared_ptr<TProtocol> proto(new MyProtocol(buffer));
+  std::shared_ptr<TMemoryBuffer> buffer(new TMemoryBuffer());
+  std::shared_ptr<TProtocol> proto(new MyProtocol(buffer));
 
   ooe.write(proto.get());
   OneOfEach ooe2;
diff --git a/lib/cpp/test/TBufferBaseTest.cpp b/lib/cpp/test/TBufferBaseTest.cpp
index 4201ddb..430302c 100644
--- a/lib/cpp/test/TBufferBaseTest.cpp
+++ b/lib/cpp/test/TBufferBaseTest.cpp
@@ -21,9 +21,9 @@
 #include <boost/test/auto_unit_test.hpp>
 #include <thrift/transport/TBufferTransports.h>
 #include <thrift/transport/TShortReadTransport.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 using apache::thrift::transport::TMemoryBuffer;
 using apache::thrift::transport::TBufferedTransport;
 using apache::thrift::transport::TFramedTransport;
diff --git a/lib/cpp/test/TMemoryBufferTest.cpp b/lib/cpp/test/TMemoryBufferTest.cpp
index d81b1d8..9206872 100644
--- a/lib/cpp/test/TMemoryBufferTest.cpp
+++ b/lib/cpp/test/TMemoryBufferTest.cpp
@@ -22,7 +22,7 @@
 #include <climits>
 #include <vector>
 #include <thrift/protocol/TBinaryProtocol.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TBufferTransports.h>
 #include "gen-cpp/ThriftTest_types.h"
 
@@ -31,7 +31,7 @@
 using apache::thrift::protocol::TBinaryProtocol;
 using apache::thrift::transport::TMemoryBuffer;
 using apache::thrift::transport::TTransportException;
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 using std::cout;
 using std::endl;
 using std::string;
diff --git a/lib/cpp/test/TNonblockingSSLServerTest.cpp b/lib/cpp/test/TNonblockingSSLServerTest.cpp
index 2efb140..330380b 100644
--- a/lib/cpp/test/TNonblockingSSLServerTest.cpp
+++ b/lib/cpp/test/TNonblockingSSLServerTest.cpp
@@ -19,8 +19,6 @@
 
 #define BOOST_TEST_MODULE TNonblockingSSLServerTest
 #include <boost/test/unit_test.hpp>
-#include <boost/smart_ptr.hpp>
-#include <boost/shared_ptr.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/format.hpp>
 
@@ -105,8 +103,8 @@
 BOOST_GLOBAL_FIXTURE(GlobalFixtureSSL)
 #endif
 
-stdcxx::shared_ptr<TSSLSocketFactory> createServerSocketFactory() {
-  stdcxx::shared_ptr<TSSLSocketFactory> pServerSocketFactory;
+std::shared_ptr<TSSLSocketFactory> createServerSocketFactory() {
+  std::shared_ptr<TSSLSocketFactory> pServerSocketFactory;
 
   pServerSocketFactory.reset(new TSSLSocketFactory());
   pServerSocketFactory->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
@@ -116,8 +114,8 @@
   return pServerSocketFactory;
 }
 
-stdcxx::shared_ptr<TSSLSocketFactory> createClientSocketFactory() {
-  stdcxx::shared_ptr<TSSLSocketFactory> pClientSocketFactory;
+std::shared_ptr<TSSLSocketFactory> createClientSocketFactory() {
+  std::shared_ptr<TSSLSocketFactory> pClientSocketFactory;
 
   pClientSocketFactory.reset(new TSSLSocketFactory());
   pClientSocketFactory->authenticate(true);
@@ -145,12 +143,12 @@
 
   struct Runner : public apache::thrift::concurrency::Runnable {
     int port;
-    stdcxx::shared_ptr<event_base> userEventBase;
-    stdcxx::shared_ptr<TProcessor> processor;
-    stdcxx::shared_ptr<server::TNonblockingServer> server;
-    stdcxx::shared_ptr<ListenEventHandler> listenHandler;
-    stdcxx::shared_ptr<TSSLSocketFactory> pServerSocketFactory;
-    stdcxx::shared_ptr<transport::TNonblockingSSLServerSocket> socket;
+    std::shared_ptr<event_base> userEventBase;
+    std::shared_ptr<TProcessor> processor;
+    std::shared_ptr<server::TNonblockingServer> server;
+    std::shared_ptr<ListenEventHandler> listenHandler;
+    std::shared_ptr<TSSLSocketFactory> pServerSocketFactory;
+    std::shared_ptr<transport::TNonblockingSSLServerSocket> socket;
     Mutex mutex_;
 
     Runner() {
@@ -198,7 +196,7 @@
   };
 
 protected:
-  Fixture() : processor(new test::ParentServiceProcessor(stdcxx::make_shared<Handler>())) {}
+  Fixture() : processor(new test::ParentServiceProcessor(std::make_shared<Handler>())) {}
 
   ~Fixture() {
     if (server) {
@@ -214,12 +212,12 @@
   }
 
   int startServer(int port) {
-    stdcxx::shared_ptr<Runner> runner(new Runner);
+    std::shared_ptr<Runner> runner(new Runner);
     runner->port = port;
     runner->processor = processor;
     runner->userEventBase = userEventBase_;
 
-    apache::thrift::stdcxx::scoped_ptr<apache::thrift::concurrency::ThreadFactory> threadFactory(
+    std::unique_ptr<apache::thrift::concurrency::ThreadFactory> threadFactory(
         new apache::thrift::concurrency::PlatformThreadFactory(
 #if !USE_STD_THREAD
             concurrency::PlatformThreadFactory::OTHER, concurrency::PlatformThreadFactory::NORMAL,
@@ -235,11 +233,11 @@
   }
 
   bool canCommunicate(int serverPort) {
-    stdcxx::shared_ptr<TSSLSocketFactory> pClientSocketFactory = createClientSocketFactory();
-    stdcxx::shared_ptr<TSSLSocket> socket = pClientSocketFactory->createSocket("localhost", serverPort);
+    std::shared_ptr<TSSLSocketFactory> pClientSocketFactory = createClientSocketFactory();
+    std::shared_ptr<TSSLSocket> socket = pClientSocketFactory->createSocket("localhost", serverPort);
     socket->open();
-    test::ParentServiceClient client(stdcxx::make_shared<protocol::TBinaryProtocol>(
-        stdcxx::make_shared<transport::TFramedTransport>(socket)));
+    test::ParentServiceClient client(std::make_shared<protocol::TBinaryProtocol>(
+        std::make_shared<transport::TFramedTransport>(socket)));
     client.addString("foo");
     std::vector<std::string> strings;
     client.getStrings(strings);
@@ -247,12 +245,12 @@
   }
 
 private:
-  stdcxx::shared_ptr<event_base> userEventBase_;
-  stdcxx::shared_ptr<test::ParentServiceProcessor> processor;
+  std::shared_ptr<event_base> userEventBase_;
+  std::shared_ptr<test::ParentServiceProcessor> processor;
 protected:
-  stdcxx::shared_ptr<server::TNonblockingServer> server;
+  std::shared_ptr<server::TNonblockingServer> server;
 private:
-  stdcxx::shared_ptr<apache::thrift::concurrency::Thread> thread;
+  std::shared_ptr<apache::thrift::concurrency::Thread> thread;
 
 };
 
diff --git a/lib/cpp/test/TNonblockingServerTest.cpp b/lib/cpp/test/TNonblockingServerTest.cpp
index 5e10907..f0bb283 100644
--- a/lib/cpp/test/TNonblockingServerTest.cpp
+++ b/lib/cpp/test/TNonblockingServerTest.cpp
@@ -19,12 +19,12 @@
 
 #define BOOST_TEST_MODULE TNonblockingServerTest
 #include <boost/test/unit_test.hpp>
+#include <memory>
 
 #include "thrift/concurrency/Monitor.h"
 #include "thrift/concurrency/Thread.h"
 #include "thrift/server/TNonblockingServer.h"
 #include "thrift/transport/TNonblockingServerSocket.h"
-#include "thrift/stdcxx.h"
 
 #include "gen-cpp/ParentService.h"
 
@@ -38,8 +38,8 @@
 using apache::thrift::concurrency::Thread;
 using apache::thrift::concurrency::ThreadFactory;
 using apache::thrift::server::TServerEventHandler;
-using apache::thrift::stdcxx::make_shared;
-using apache::thrift::stdcxx::shared_ptr;
+using std::make_shared;
+using std::shared_ptr;
 
 using namespace apache::thrift;
 
diff --git a/lib/cpp/test/TPipeInterruptTest.cpp b/lib/cpp/test/TPipeInterruptTest.cpp
index 232e4bb..2423f56 100644
--- a/lib/cpp/test/TPipeInterruptTest.cpp
+++ b/lib/cpp/test/TPipeInterruptTest.cpp
@@ -27,7 +27,7 @@
 #include <boost/thread/thread.hpp>
 #include <thrift/transport/TPipe.h>
 #include <thrift/transport/TPipeServer.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 using apache::thrift::transport::TPipeServer;
 using apache::thrift::transport::TPipe;
@@ -52,7 +52,7 @@
   {
     for (;;)
     {
-      stdcxx::shared_ptr<TTransport> temp = pipe->accept();
+      std::shared_ptr<TTransport> temp = pipe->accept();
     }
   }
   catch (...) {/*just want to make sure nothing crashes*/ }
@@ -70,8 +70,8 @@
   {
     TPipeServer pipeServer("TPipeInterruptTest");
     pipeServer.listen();
-    boost::thread acceptThread(stdcxx::bind(acceptWorker, &pipeServer));
-    boost::thread interruptThread(stdcxx::bind(interruptWorker, &pipeServer));
+    boost::thread acceptThread(std::bind(acceptWorker, &pipeServer));
+    boost::thread interruptThread(std::bind(interruptWorker, &pipeServer));
     try
     {
       for (;;)
diff --git a/lib/cpp/test/TPipedTransportTest.cpp b/lib/cpp/test/TPipedTransportTest.cpp
index a3ce662..f3091a4 100644
--- a/lib/cpp/test/TPipedTransportTest.cpp
+++ b/lib/cpp/test/TPipedTransportTest.cpp
@@ -18,7 +18,7 @@
  */
 
 #include <thrift/Thrift.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TTransportUtils.h>
 #include <thrift/transport/TBufferTransports.h>
 
@@ -31,9 +31,9 @@
 using namespace apache::thrift;
 
 BOOST_AUTO_TEST_CASE(test_read_write) {
-  stdcxx::shared_ptr<TMemoryBuffer> underlying(new TMemoryBuffer);
-  stdcxx::shared_ptr<TMemoryBuffer> pipe(new TMemoryBuffer);
-  stdcxx::shared_ptr<TPipedTransport> trans(new TPipedTransport(underlying, pipe));
+  std::shared_ptr<TMemoryBuffer> underlying(new TMemoryBuffer);
+  std::shared_ptr<TMemoryBuffer> pipe(new TMemoryBuffer);
+  std::shared_ptr<TPipedTransport> trans(new TPipedTransport(underlying, pipe));
 
   uint8_t buffer[4];
 
diff --git a/lib/cpp/test/TSSLSocketInterruptTest.cpp b/lib/cpp/test/TSSLSocketInterruptTest.cpp
index 85f6c39..33f686c 100644
--- a/lib/cpp/test/TSSLSocketInterruptTest.cpp
+++ b/lib/cpp/test/TSSLSocketInterruptTest.cpp
@@ -24,7 +24,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/format.hpp>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/transport/TSSLSocket.h>
 #include <thrift/transport/TSSLServerSocket.h>
 #ifdef __linux__
@@ -37,8 +37,8 @@
 using apache::thrift::transport::TTransportException;
 using apache::thrift::transport::TSSLSocketFactory;
 
-using apache::thrift::stdcxx::static_pointer_cast;
-using apache::thrift::stdcxx::shared_ptr;
+using std::static_pointer_cast;
+using std::shared_ptr;
 
 BOOST_AUTO_TEST_SUITE(TSSLSocketInterruptTest)
 
@@ -146,7 +146,7 @@
   shared_ptr<TSSLSocket> clientSock = pClientSocketFactory->createSocket("localhost", port);
   clientSock->open();
   shared_ptr<TTransport> accepted = sock1.accept();
-  boost::thread readThread(apache::thrift::stdcxx::bind(readerWorkerMustThrow, accepted));
+  boost::thread readThread(std::bind(readerWorkerMustThrow, accepted));
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // readThread is practically guaranteed to be blocking now
   sock1.interruptChildren();
@@ -166,7 +166,7 @@
   shared_ptr<TSSLSocket> clientSock = pClientSocketFactory->createSocket("localhost", port);
   clientSock->open();
   shared_ptr<TTransport> accepted = sock1.accept();
-  boost::thread readThread(apache::thrift::stdcxx::bind(readerWorkerMustThrow, accepted));
+  boost::thread readThread(std::bind(readerWorkerMustThrow, accepted));
   clientSock->write((const uint8_t*)"0", 1);
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // readThread is practically guaranteed to be blocking now
@@ -189,7 +189,7 @@
   clientSock->open();
   shared_ptr<TTransport> accepted = sock1.accept();
   static_pointer_cast<TSSLSocket>(accepted)->setRecvTimeout(1000);
-  boost::thread readThread(apache::thrift::stdcxx::bind(readerWorker, accepted, 0));
+  boost::thread readThread(std::bind(readerWorker, accepted, 0));
   clientSock->write((const uint8_t*)"0", 1);
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // readThread is practically guaranteed to be blocking here
@@ -241,7 +241,7 @@
   shared_ptr<TSSLSocket> clientSock = pClientSocketFactory->createSocket("localhost", port);
   clientSock->open();
   shared_ptr<TTransport> accepted = sock1.accept();
-  boost::thread peekThread(apache::thrift::stdcxx::bind(peekerWorkerInterrupt, accepted));
+  boost::thread peekThread(std::bind(peekerWorkerInterrupt, accepted));
   clientSock->write((const uint8_t*)"0", 1);
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // peekThread is practically guaranteed to be blocking now
@@ -264,7 +264,7 @@
   clientSock->open();
   shared_ptr<TTransport> accepted = sock1.accept();
   static_pointer_cast<TSSLSocket>(accepted)->setRecvTimeout(1000);
-  boost::thread peekThread(apache::thrift::stdcxx::bind(peekerWorker, accepted, false));
+  boost::thread peekThread(std::bind(peekerWorker, accepted, false));
   clientSock->write((const uint8_t*)"0", 1);
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // peekThread is practically guaranteed to be blocking now
diff --git a/lib/cpp/test/TServerIntegrationTest.cpp b/lib/cpp/test/TServerIntegrationTest.cpp
index 5f7b2e8..3723679 100644
--- a/lib/cpp/test/TServerIntegrationTest.cpp
+++ b/lib/cpp/test/TServerIntegrationTest.cpp
@@ -27,7 +27,7 @@
 #include <thrift/server/TSimpleServer.h>
 #include <thrift/server/TThreadPoolServer.h>
 #include <thrift/server/TThreadedServer.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include <thrift/protocol/TBinaryProtocol.h>
 #include <thrift/transport/TServerSocket.h>
 #include <thrift/transport/TSocket.h>
@@ -55,9 +55,9 @@
 using apache::thrift::server::TSimpleServer;
 using apache::thrift::server::TThreadPoolServer;
 using apache::thrift::server::TThreadedServer;
-using apache::thrift::stdcxx::dynamic_pointer_cast;
-using apache::thrift::stdcxx::make_shared;
-using apache::thrift::stdcxx::shared_ptr;
+using std::dynamic_pointer_cast;
+using std::make_shared;
+using std::shared_ptr;
 using apache::thrift::test::ParentServiceClient;
 using apache::thrift::test::ParentServiceIf;
 using apache::thrift::test::ParentServiceIfFactory;
@@ -177,7 +177,7 @@
   }
 
   void startServer() {
-    pServerThread.reset(new boost::thread(apache::thrift::stdcxx::bind(&TServerType::serve, pServer.get())));
+    pServerThread.reset(new boost::thread(std::bind(&TServerType::serve, pServer.get())));
 
     // block until listen() completes so clients will be able to connect
     Synchronized sync(*(pEventHandler.get()));
@@ -235,7 +235,7 @@
       pClientSock->open();
       client.incrementGeneration();
       holdThreads.push_back(shared_ptr<boost::thread>(
-          new boost::thread(apache::thrift::stdcxx::bind(&TServerIntegrationTestFixture::delayClose,
+          new boost::thread(std::bind(&TServerIntegrationTestFixture::delayClose,
                                         this,
                                         pClientSock,
                                         milliseconds(10 * numToMake)))));
@@ -284,7 +284,7 @@
     std::vector<shared_ptr<boost::thread> > holdThreads;
     for (int64_t i = 0; i < numToMake; ++i) {
       holdThreads.push_back(shared_ptr<boost::thread>(
-        new boost::thread(apache::thrift::stdcxx::bind(&TServerIntegrationTestFixture::stressor, this))));
+        new boost::thread(std::bind(&TServerIntegrationTestFixture::stressor, this))));
     }
 
     boost::this_thread::sleep(duration);
@@ -479,11 +479,11 @@
   // Ensure they have been accepted
   blockUntilAccepted(2);
 
-  boost::thread t1(apache::thrift::stdcxx::bind(&TServerIntegrationTestFixture::delayClose,
+  boost::thread t1(std::bind(&TServerIntegrationTestFixture::delayClose,
                                this,
                                pClientSock1,
                                milliseconds(250)));
-  boost::thread t2(apache::thrift::stdcxx::bind(&TServerIntegrationTestFixture::delayClose,
+  boost::thread t2(std::bind(&TServerIntegrationTestFixture::delayClose,
                                this,
                                pClientSock2,
                                milliseconds(250)));
@@ -517,7 +517,7 @@
   BOOST_CHECK_EQUAL(2, pServer->getConcurrentClientCount());
 
   // a third client cannot connect until one of the other two closes
-  boost::thread t2(apache::thrift::stdcxx::bind(&TServerIntegrationTestFixture::delayClose,
+  boost::thread t2(std::bind(&TServerIntegrationTestFixture::delayClose,
                                this,
                                pClientSock2,
                                milliseconds(250)));
diff --git a/lib/cpp/test/TServerSocketTest.cpp b/lib/cpp/test/TServerSocketTest.cpp
index a191147..bec6d47 100644
--- a/lib/cpp/test/TServerSocketTest.cpp
+++ b/lib/cpp/test/TServerSocketTest.cpp
@@ -20,7 +20,7 @@
 #include <boost/test/auto_unit_test.hpp>
 #include <thrift/transport/TSocket.h>
 #include <thrift/transport/TServerSocket.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 #include "TTransportCheckThrow.h"
 #include <iostream>
 
@@ -28,7 +28,7 @@
 using apache::thrift::transport::TSocket;
 using apache::thrift::transport::TTransport;
 using apache::thrift::transport::TTransportException;
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 
 BOOST_AUTO_TEST_SUITE(TServerSocketTest)
 
diff --git a/lib/cpp/test/TServerTransportTest.cpp b/lib/cpp/test/TServerTransportTest.cpp
index dc6aede..539bd28 100644
--- a/lib/cpp/test/TServerTransportTest.cpp
+++ b/lib/cpp/test/TServerTransportTest.cpp
@@ -20,12 +20,12 @@
 #include <boost/test/auto_unit_test.hpp>
 #include <thrift/transport/TSocket.h>
 #include <thrift/transport/TServerTransport.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 using apache::thrift::transport::TServerTransport;
 using apache::thrift::transport::TTransport;
 using apache::thrift::transport::TTransportException;
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 
 BOOST_AUTO_TEST_SUITE(TServerTransportTest)
 
diff --git a/lib/cpp/test/TSocketInterruptTest.cpp b/lib/cpp/test/TSocketInterruptTest.cpp
index 3a189cc..366242f 100644
--- a/lib/cpp/test/TSocketInterruptTest.cpp
+++ b/lib/cpp/test/TSocketInterruptTest.cpp
@@ -25,7 +25,7 @@
 #include <boost/thread/thread.hpp>
 #include <thrift/transport/TSocket.h>
 #include <thrift/transport/TServerSocket.h>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 using apache::thrift::transport::TServerSocket;
 using apache::thrift::transport::TSocket;
@@ -35,12 +35,12 @@
 
 BOOST_AUTO_TEST_SUITE(TSocketInterruptTest)
 
-void readerWorker(stdcxx::shared_ptr<TTransport> tt, uint32_t expectedResult) {
+void readerWorker(std::shared_ptr<TTransport> tt, uint32_t expectedResult) {
   uint8_t buf[4];
   BOOST_CHECK_EQUAL(expectedResult, tt->read(buf, 4));
 }
 
-void readerWorkerMustThrow(stdcxx::shared_ptr<TTransport> tt) {
+void readerWorkerMustThrow(std::shared_ptr<TTransport> tt) {
   try {
     uint8_t buf[4];
     tt->read(buf, 4);
@@ -56,8 +56,8 @@
   int port = sock1.getPort();
   TSocket clientSock("localhost", port);
   clientSock.open();
-  stdcxx::shared_ptr<TTransport> accepted = sock1.accept();
-  boost::thread readThread(stdcxx::bind(readerWorkerMustThrow, accepted));
+  std::shared_ptr<TTransport> accepted = sock1.accept();
+  boost::thread readThread(std::bind(readerWorkerMustThrow, accepted));
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // readThread is practically guaranteed to be blocking now
   sock1.interruptChildren();
@@ -75,8 +75,8 @@
   int port = sock1.getPort();
   TSocket clientSock("localhost", port);
   clientSock.open();
-  stdcxx::shared_ptr<TTransport> accepted = sock1.accept();
-  boost::thread readThread(stdcxx::bind(readerWorker, accepted, 0));
+  std::shared_ptr<TTransport> accepted = sock1.accept();
+  boost::thread readThread(std::bind(readerWorker, accepted, 0));
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // readThread is practically guaranteed to be blocking here
   sock1.interruptChildren();
@@ -97,7 +97,7 @@
   sock1.close();
 }
 
-void peekerWorker(stdcxx::shared_ptr<TTransport> tt, bool expectedResult) {
+void peekerWorker(std::shared_ptr<TTransport> tt, bool expectedResult) {
   BOOST_CHECK_EQUAL(expectedResult, tt->peek());
 }
 
@@ -107,9 +107,9 @@
   int port = sock1.getPort();
   TSocket clientSock("localhost", port);
   clientSock.open();
-  stdcxx::shared_ptr<TTransport> accepted = sock1.accept();
+  std::shared_ptr<TTransport> accepted = sock1.accept();
   // peek() will return false if child is interrupted
-  boost::thread peekThread(stdcxx::bind(peekerWorker, accepted, false));
+  boost::thread peekThread(std::bind(peekerWorker, accepted, false));
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // peekThread is practically guaranteed to be blocking now
   sock1.interruptChildren();
@@ -127,9 +127,9 @@
   int port = sock1.getPort();
   TSocket clientSock("localhost", port);
   clientSock.open();
-  stdcxx::shared_ptr<TTransport> accepted = sock1.accept();
+  std::shared_ptr<TTransport> accepted = sock1.accept();
   // peek() will return false when remote side is closed
-  boost::thread peekThread(stdcxx::bind(peekerWorker, accepted, false));
+  boost::thread peekThread(std::bind(peekerWorker, accepted, false));
   boost::this_thread::sleep(boost::posix_time::milliseconds(50));
   // peekThread is practically guaranteed to be blocking now
   sock1.interruptChildren();
diff --git a/lib/cpp/test/TransportTest.cpp b/lib/cpp/test/TransportTest.cpp
index d6ab457..ce19544 100644
--- a/lib/cpp/test/TransportTest.cpp
+++ b/lib/cpp/test/TransportTest.cpp
@@ -26,7 +26,6 @@
 #endif
 #include <sstream>
 #include <fstream>
-#include <thrift/stdcxx.h>
 
 #include <boost/mpl/list.hpp>
 #include <boost/shared_array.hpp>
@@ -114,7 +113,7 @@
   std::string describe() const { return generator_->describe(); }
 
 private:
-  stdcxx::shared_ptr<SizeGenerator> generator_;
+  std::shared_ptr<SizeGenerator> generator_;
 };
 
 /**************************************************************************
@@ -137,8 +136,8 @@
 
   CoupledTransports() : in(), out() {}
 
-  stdcxx::shared_ptr<Transport_> in;
-  stdcxx::shared_ptr<Transport_> out;
+  std::shared_ptr<Transport_> in;
+  std::shared_ptr<Transport_> out;
 
 private:
   CoupledTransports(const CoupledTransports&);
@@ -155,7 +154,7 @@
     out = buf;
   }
 
-  stdcxx::shared_ptr<TMemoryBuffer> buf;
+  std::shared_ptr<TMemoryBuffer> buf;
 };
 
 /**
@@ -341,11 +340,11 @@
  **************************************************************************/
 
 struct TriggerInfo {
-  TriggerInfo(int seconds, const stdcxx::shared_ptr<TTransport>& transport, uint32_t writeLength)
+  TriggerInfo(int seconds, const std::shared_ptr<TTransport>& transport, uint32_t writeLength)
     : timeoutSeconds(seconds), transport(transport), writeLength(writeLength), next(NULL) {}
 
   int timeoutSeconds;
-  stdcxx::shared_ptr<TTransport> transport;
+  std::shared_ptr<TTransport> transport;
   uint32_t writeLength;
   TriggerInfo* next;
 };
@@ -420,7 +419,7 @@
  * to the end.)
  */
 void add_trigger(unsigned int seconds,
-                 const stdcxx::shared_ptr<TTransport>& transport,
+                 const std::shared_ptr<TTransport>& transport,
                  uint32_t write_len) {
   TriggerInfo* info = new TriggerInfo(seconds, transport, write_len);
   {
@@ -460,7 +459,7 @@
 }
 
 void set_trigger(unsigned int seconds,
-                 const stdcxx::shared_ptr<TTransport>& transport,
+                 const std::shared_ptr<TTransport>& transport,
                  uint32_t write_len) {
   clear_triggers();
   add_trigger(seconds, transport, write_len);
@@ -976,11 +975,11 @@
          << rChunkSizeGen.describe() << ", " << maxOutstanding << ")";
 
 #if (BOOST_VERSION >= 105900)
-    stdcxx::function<void ()> test_func
+    std::function<void ()> test_func
 #else
     boost::unit_test::callback0<> test_func
 #endif
-        = stdcxx::bind(test_rw<CoupledTransports>,
+        = std::bind(test_rw<CoupledTransports>,
                                        totalSize,
                                        wSizeGen,
                                        rSizeGen,
@@ -1026,7 +1025,7 @@
  **************************************************************************/
 
 struct global_fixture {
-  stdcxx::shared_ptr<apache::thrift::concurrency::Thread> alarmThread_;
+  std::shared_ptr<apache::thrift::concurrency::Thread> alarmThread_;
   global_fixture() {
 #if _WIN32
     apache::thrift::transport::TWinsockSingleton::create();
diff --git a/lib/cpp/test/ZlibTest.cpp b/lib/cpp/test/ZlibTest.cpp
index ea54487..c826814 100644
--- a/lib/cpp/test/ZlibTest.cpp
+++ b/lib/cpp/test/ZlibTest.cpp
@@ -36,7 +36,7 @@
 #include <cstddef>
 #include <fstream>
 #include <iostream>
-#include <thrift/stdcxx.h>
+#include <memory>
 
 #include <boost/random.hpp>
 #include <boost/shared_array.hpp>
@@ -47,7 +47,7 @@
 #include <thrift/transport/TZlibTransport.h>
 
 using namespace apache::thrift::transport;
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 using std::string;
 
 boost::mt19937 rng;
@@ -347,8 +347,8 @@
   do {                                                                                             \
     ::std::ostringstream name_ss;                                                                  \
     name_ss << name << "-" << BOOST_STRINGIZE(_FUNC);                                              \
-    ::apache::thrift::stdcxx::function<void ()> test_func =                                        \
-        ::apache::thrift::stdcxx::bind(_FUNC, ##__VA_ARGS__);                                      \
+    ::std::function<void ()> test_func =                                        \
+        ::std::bind(_FUNC, ##__VA_ARGS__);                                      \
     ::boost::unit_test::test_case* tc                                                              \
         = ::boost::unit_test::make_test_case(test_func, name_ss.str(), __FILE__, __LINE__);        \
     (suite)->add(tc);                                                                              \
@@ -359,7 +359,7 @@
     ::std::ostringstream name_ss;                                                                  \
     name_ss << name << "-" << BOOST_STRINGIZE(_FUNC);                                              \
     ::boost::unit_test::test_case* tc                                                              \
-        = ::boost::unit_test::make_test_case(::apache::thrift::stdcxx::bind(_FUNC,                 \
+        = ::boost::unit_test::make_test_case(::std::bind(_FUNC,                 \
                                                                             ##__VA_ARGS__),        \
                                              name_ss.str());                                       \
     (suite)->add(tc);                                                                              \
diff --git a/lib/cpp/test/concurrency/RWMutexStarveTest.cpp b/lib/cpp/test/concurrency/RWMutexStarveTest.cpp
index 849e078..985a230 100644
--- a/lib/cpp/test/concurrency/RWMutexStarveTest.cpp
+++ b/lib/cpp/test/concurrency/RWMutexStarveTest.cpp
@@ -23,9 +23,9 @@
 
 #include "thrift/concurrency/Mutex.h"
 #include "thrift/concurrency/PosixThreadFactory.h"
-#include <thrift/stdcxx.h>
+#include <memory>
 
-using apache::thrift::stdcxx::shared_ptr;
+using std::shared_ptr;
 using boost::unit_test::test_suite;
 using boost::unit_test::framework::master_test_suite;
 
diff --git a/lib/cpp/test/concurrency/ThreadFactoryTests.h b/lib/cpp/test/concurrency/ThreadFactoryTests.h
index 48330f3..ba98502 100644
--- a/lib/cpp/test/concurrency/ThreadFactoryTests.h
+++ b/lib/cpp/test/concurrency/ThreadFactoryTests.h
@@ -33,7 +33,7 @@
 namespace concurrency {
 namespace test {
 
-using stdcxx::shared_ptr;
+using std::shared_ptr;
 using namespace apache::thrift::concurrency;
 
 /**
diff --git a/lib/cpp/test/concurrency/ThreadManagerTests.h b/lib/cpp/test/concurrency/ThreadManagerTests.h
index 15a43ff..d6c092d 100644
--- a/lib/cpp/test/concurrency/ThreadManagerTests.h
+++ b/lib/cpp/test/concurrency/ThreadManagerTests.h
@@ -36,8 +36,8 @@
 
 using namespace apache::thrift::concurrency;
 
-static std::deque<stdcxx::shared_ptr<Runnable> > m_expired;
-static void expiredNotifier(stdcxx::shared_ptr<Runnable> runnable)
+static std::deque<std::shared_ptr<Runnable> > m_expired;
+static void expiredNotifier(std::shared_ptr<Runnable> runnable)
 {
   m_expired.push_back(runnable);
 }
@@ -452,7 +452,7 @@
     std::cout << "\t\t\t\tstarting.. " << std::endl;
 
     threadManager->start();
-    threadManager->setExpireCallback(expiredNotifier); // apache::thrift::stdcxx::bind(&ThreadManagerTests::expiredNotifier, this));
+    threadManager->setExpireCallback(expiredNotifier); // std::bind(&ThreadManagerTests::expiredNotifier, this));
 
 #define EXPECT(FUNC, COUNT) { size_t c = FUNC; if (c != COUNT) { std::cerr << "expected " #FUNC" to be " #COUNT ", but was " << c << std::endl; return false; } }
 
diff --git a/lib/cpp/test/processor/Handlers.h b/lib/cpp/test/processor/Handlers.h
index ad47229..29784d8 100644
--- a/lib/cpp/test/processor/Handlers.h
+++ b/lib/cpp/test/processor/Handlers.h
@@ -29,7 +29,7 @@
 
 class ParentHandler : virtual public ParentServiceIf {
 public:
-  ParentHandler(const stdcxx::shared_ptr<EventLog>& log)
+  ParentHandler(const std::shared_ptr<EventLog>& log)
     : triggerMonitor(&mutex_), generation_(0), wait_(false), log_(log) {}
 
   int32_t incrementGeneration() {
@@ -136,7 +136,7 @@
   int32_t generation_;
   bool wait_;
   std::vector<std::string> strings_;
-  stdcxx::shared_ptr<EventLog> log_;
+  std::shared_ptr<EventLog> log_;
 };
 
 #ifdef _WIN32
@@ -146,7 +146,7 @@
 
 class ChildHandler : public ParentHandler, virtual public ChildServiceIf {
 public:
-  ChildHandler(const stdcxx::shared_ptr<EventLog>& log) : ParentHandler(log), value_(0) {}
+  ChildHandler(const std::shared_ptr<EventLog>& log) : ParentHandler(log), value_(0) {}
 
   int32_t setValue(const int32_t value) {
     concurrency::Guard g(mutex_);
@@ -174,13 +174,13 @@
 
 struct ConnContext {
 public:
-  ConnContext(stdcxx::shared_ptr<protocol::TProtocol> in,
-              stdcxx::shared_ptr<protocol::TProtocol> out,
+  ConnContext(std::shared_ptr<protocol::TProtocol> in,
+              std::shared_ptr<protocol::TProtocol> out,
               uint32_t id)
     : input(in), output(out), id(id) {}
 
-  stdcxx::shared_ptr<protocol::TProtocol> input;
-  stdcxx::shared_ptr<protocol::TProtocol> output;
+  std::shared_ptr<protocol::TProtocol> input;
+  std::shared_ptr<protocol::TProtocol> output;
   uint32_t id;
 };
 
@@ -196,12 +196,12 @@
 
 class ServerEventHandler : public server::TServerEventHandler {
 public:
-  ServerEventHandler(const stdcxx::shared_ptr<EventLog>& log) : nextId_(1), log_(log) {}
+  ServerEventHandler(const std::shared_ptr<EventLog>& log) : nextId_(1), log_(log) {}
 
   virtual void preServe() {}
 
-  virtual void* createContext(stdcxx::shared_ptr<protocol::TProtocol> input,
-                              stdcxx::shared_ptr<protocol::TProtocol> output) {
+  virtual void* createContext(std::shared_ptr<protocol::TProtocol> input,
+                              std::shared_ptr<protocol::TProtocol> output) {
     ConnContext* context = new ConnContext(input, output, nextId_);
     ++nextId_;
     log_->append(EventLog::ET_CONN_CREATED, context->id, 0);
@@ -209,8 +209,8 @@
   }
 
   virtual void deleteContext(void* serverContext,
-                             stdcxx::shared_ptr<protocol::TProtocol> input,
-                             stdcxx::shared_ptr<protocol::TProtocol> output) {
+                             std::shared_ptr<protocol::TProtocol> input,
+                             std::shared_ptr<protocol::TProtocol> output) {
     ConnContext* context = reinterpret_cast<ConnContext*>(serverContext);
 
     if (input != context->input) {
@@ -226,7 +226,7 @@
   }
 
   virtual void processContext(void* serverContext,
-                              stdcxx::shared_ptr<transport::TTransport> transport) {
+                              std::shared_ptr<transport::TTransport> transport) {
 // TODO: We currently don't test the behavior of the processContext()
 // calls.  The various server implementations call processContext() at
 // slightly different times, and it is too annoying to try and account for
@@ -251,12 +251,12 @@
 
 protected:
   uint32_t nextId_;
-  stdcxx::shared_ptr<EventLog> log_;
+  std::shared_ptr<EventLog> log_;
 };
 
 class ProcessorEventHandler : public TProcessorEventHandler {
 public:
-  ProcessorEventHandler(const stdcxx::shared_ptr<EventLog>& log) : nextId_(1), log_(log) {}
+  ProcessorEventHandler(const std::shared_ptr<EventLog>& log) : nextId_(1), log_(log) {}
 
   void* getContext(const char* fnName, void* serverContext) {
     ConnContext* connContext = reinterpret_cast<ConnContext*>(serverContext);
@@ -329,7 +329,7 @@
   }
 
   uint32_t nextId_;
-  stdcxx::shared_ptr<EventLog> log_;
+  std::shared_ptr<EventLog> log_;
 };
 }
 }
diff --git a/lib/cpp/test/processor/ProcessorTest.cpp b/lib/cpp/test/processor/ProcessorTest.cpp
index c9e186f..36ce013 100644
--- a/lib/cpp/test/processor/ProcessorTest.cpp
+++ b/lib/cpp/test/processor/ProcessorTest.cpp
@@ -57,13 +57,13 @@
 public:
   typedef TSimpleServer ServerType;
 
-  stdcxx::shared_ptr<TSimpleServer> createServer(
-      const stdcxx::shared_ptr<TProcessor>& processor,
+  std::shared_ptr<TSimpleServer> createServer(
+      const std::shared_ptr<TProcessor>& processor,
       uint16_t port,
-      const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory) {
-    stdcxx::shared_ptr<TServerSocket> socket(new TServerSocket(port));
-    return stdcxx::shared_ptr<TSimpleServer>(
+      const std::shared_ptr<TTransportFactory>& transportFactory,
+      const std::shared_ptr<TProtocolFactory>& protocolFactory) {
+    std::shared_ptr<TServerSocket> socket(new TServerSocket(port));
+    return std::shared_ptr<TSimpleServer>(
         new TSimpleServer(processor, socket, transportFactory, protocolFactory));
   }
 };
@@ -72,13 +72,13 @@
 public:
   typedef TThreadedServer ServerType;
 
-  stdcxx::shared_ptr<TThreadedServer> createServer(
-      const stdcxx::shared_ptr<TProcessor>& processor,
+  std::shared_ptr<TThreadedServer> createServer(
+      const std::shared_ptr<TProcessor>& processor,
       uint16_t port,
-      const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory) {
-    stdcxx::shared_ptr<TServerSocket> socket(new TServerSocket(port));
-    return stdcxx::shared_ptr<TThreadedServer>(
+      const std::shared_ptr<TTransportFactory>& transportFactory,
+      const std::shared_ptr<TProtocolFactory>& protocolFactory) {
+    std::shared_ptr<TServerSocket> socket(new TServerSocket(port));
+    return std::shared_ptr<TThreadedServer>(
         new TThreadedServer(processor, socket, transportFactory, protocolFactory));
   }
 };
@@ -87,19 +87,19 @@
 public:
   typedef TThreadPoolServer ServerType;
 
-  stdcxx::shared_ptr<TThreadPoolServer> createServer(
-      const stdcxx::shared_ptr<TProcessor>& processor,
+  std::shared_ptr<TThreadPoolServer> createServer(
+      const std::shared_ptr<TProcessor>& processor,
       uint16_t port,
-      const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory) {
-    stdcxx::shared_ptr<TServerSocket> socket(new TServerSocket(port));
+      const std::shared_ptr<TTransportFactory>& transportFactory,
+      const std::shared_ptr<TProtocolFactory>& protocolFactory) {
+    std::shared_ptr<TServerSocket> socket(new TServerSocket(port));
 
-    stdcxx::shared_ptr<PlatformThreadFactory> threadFactory(new PlatformThreadFactory);
-    stdcxx::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(8);
+    std::shared_ptr<PlatformThreadFactory> threadFactory(new PlatformThreadFactory);
+    std::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(8);
     threadManager->threadFactory(threadFactory);
     threadManager->start();
 
-    return stdcxx::shared_ptr<TThreadPoolServer>(
+    return std::shared_ptr<TThreadPoolServer>(
         new TThreadPoolServer(processor, socket, transportFactory, protocolFactory, threadManager));
   }
 };
@@ -108,11 +108,11 @@
 public:
   typedef TNonblockingServer ServerType;
 
-  stdcxx::shared_ptr<TNonblockingServer> createServer(
-      const stdcxx::shared_ptr<TProcessor>& processor,
+  std::shared_ptr<TNonblockingServer> createServer(
+      const std::shared_ptr<TProcessor>& processor,
       uint16_t port,
-      const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory) {
+      const std::shared_ptr<TTransportFactory>& transportFactory,
+      const std::shared_ptr<TProtocolFactory>& protocolFactory) {
     // TNonblockingServer automatically uses TFramedTransport.
     // Raise an exception if the supplied transport factory is not a
     // TFramedTransportFactory
@@ -122,13 +122,13 @@
       throw TException("TNonblockingServer must use TFramedTransport");
     }
 
-    stdcxx::shared_ptr<TNonblockingServerSocket> socket(new TNonblockingServerSocket(port));
-    stdcxx::shared_ptr<PlatformThreadFactory> threadFactory(new PlatformThreadFactory);
-    stdcxx::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(8);
+    std::shared_ptr<TNonblockingServerSocket> socket(new TNonblockingServerSocket(port));
+    std::shared_ptr<PlatformThreadFactory> threadFactory(new PlatformThreadFactory);
+    std::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(8);
     threadManager->threadFactory(threadFactory);
     threadManager->start();
 
-    return stdcxx::shared_ptr<TNonblockingServer>(
+    return std::shared_ptr<TNonblockingServer>(
         new TNonblockingServer(processor, protocolFactory, socket, threadManager));
   }
 };
@@ -137,11 +137,11 @@
 public:
   typedef TNonblockingServer ServerType;
 
-  stdcxx::shared_ptr<TNonblockingServer> createServer(
-      const stdcxx::shared_ptr<TProcessor>& processor,
+  std::shared_ptr<TNonblockingServer> createServer(
+      const std::shared_ptr<TProcessor>& processor,
       uint16_t port,
-      const stdcxx::shared_ptr<TTransportFactory>& transportFactory,
-      const stdcxx::shared_ptr<TProtocolFactory>& protocolFactory) {
+      const std::shared_ptr<TTransportFactory>& transportFactory,
+      const std::shared_ptr<TProtocolFactory>& protocolFactory) {
     // TNonblockingServer automatically uses TFramedTransport.
     // Raise an exception if the supplied transport factory is not a
     // TFramedTransportFactory
@@ -151,10 +151,10 @@
       throw TException("TNonblockingServer must use TFramedTransport");
     }
 
-    stdcxx::shared_ptr<TNonblockingServerSocket> socket(new TNonblockingServerSocket(port));
+    std::shared_ptr<TNonblockingServerSocket> socket(new TNonblockingServerSocket(port));
     // Use a NULL ThreadManager
-    stdcxx::shared_ptr<ThreadManager> threadManager;
-    return stdcxx::shared_ptr<TNonblockingServer>(
+    std::shared_ptr<ThreadManager> threadManager;
+    return std::shared_ptr<TNonblockingServer>(
         new TNonblockingServer(processor, protocolFactory, socket, threadManager));
   }
 };
@@ -244,48 +244,48 @@
     processor_->setEventHandler(processorEventHandler_);
   }
 
-  stdcxx::shared_ptr<TServer> createServer(uint16_t port) {
+  std::shared_ptr<TServer> createServer(uint16_t port) {
     ServerTraits_ serverTraits;
     return serverTraits.createServer(processor_, port, transportFactory_, protocolFactory_);
   }
 
-  stdcxx::shared_ptr<TServerEventHandler> getServerEventHandler() { return serverEventHandler_; }
+  std::shared_ptr<TServerEventHandler> getServerEventHandler() { return serverEventHandler_; }
 
   void bindSuccessful(uint16_t port) { port_ = port; }
 
   uint16_t getPort() const { return port_; }
 
-  const stdcxx::shared_ptr<EventLog>& getLog() const { return log_; }
+  const std::shared_ptr<EventLog>& getLog() const { return log_; }
 
-  const stdcxx::shared_ptr<Handler>& getHandler() const { return handler_; }
+  const std::shared_ptr<Handler>& getHandler() const { return handler_; }
 
-  stdcxx::shared_ptr<Client> createClient() {
+  std::shared_ptr<Client> createClient() {
     typedef typename ServiceTraits_::Protocol Protocol;
 
-    stdcxx::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", port_));
-    stdcxx::shared_ptr<Transport_> transport(new Transport_(socket));
-    stdcxx::shared_ptr<Protocol> protocol(new Protocol(transport));
+    std::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", port_));
+    std::shared_ptr<Transport_> transport(new Transport_(socket));
+    std::shared_ptr<Protocol> protocol(new Protocol(transport));
     transport->open();
 
-    stdcxx::shared_ptr<Client> client(new Client(protocol));
+    std::shared_ptr<Client> client(new Client(protocol));
     return client;
   }
 
 private:
   uint16_t port_;
-  stdcxx::shared_ptr<EventLog> log_;
-  stdcxx::shared_ptr<Handler> handler_;
-  stdcxx::shared_ptr<Processor> processor_;
-  stdcxx::shared_ptr<TTransportFactory> transportFactory_;
-  stdcxx::shared_ptr<TProtocolFactory> protocolFactory_;
-  stdcxx::shared_ptr<TServerEventHandler> serverEventHandler_;
-  stdcxx::shared_ptr<TProcessorEventHandler> processorEventHandler_;
+  std::shared_ptr<EventLog> log_;
+  std::shared_ptr<Handler> handler_;
+  std::shared_ptr<Processor> processor_;
+  std::shared_ptr<TTransportFactory> transportFactory_;
+  std::shared_ptr<TProtocolFactory> protocolFactory_;
+  std::shared_ptr<TServerEventHandler> serverEventHandler_;
+  std::shared_ptr<TProcessorEventHandler> processorEventHandler_;
 };
 
 /**
  * Check that there are no more events in the log
  */
-void checkNoEvents(const stdcxx::shared_ptr<EventLog>& log) {
+void checkNoEvents(const std::shared_ptr<EventLog>& log) {
   // Wait for an event with a very short timeout period.  We don't expect
   // anything to be present, so we will normally wait for the full timeout.
   // On the other hand, a non-zero timeout is nice since it does give a short
@@ -299,7 +299,7 @@
  *
  * Returns the connection ID allocated by the server.
  */
-uint32_t checkNewConnEvents(const stdcxx::shared_ptr<EventLog>& log) {
+uint32_t checkNewConnEvents(const std::shared_ptr<EventLog>& log) {
   // Check for an ET_CONN_CREATED event
   Event event = log->waitForEvent(2500);
   BOOST_CHECK_EQUAL(EventLog::ET_CONN_CREATED, event.type);
@@ -314,7 +314,7 @@
 /**
  * Check for the events that should be logged when a connection is closed.
  */
-void checkCloseEvents(const stdcxx::shared_ptr<EventLog>& log, uint32_t connId) {
+void checkCloseEvents(const std::shared_ptr<EventLog>& log, uint32_t connId) {
   // Check for an ET_CONN_DESTROYED event
   Event event = log->waitForEvent();
   BOOST_CHECK_EQUAL(EventLog::ET_CONN_DESTROYED, event.type);
@@ -332,7 +332,7 @@
  *
  * Returns the call ID allocated by the server.
  */
-uint32_t checkCallHandlerEvents(const stdcxx::shared_ptr<EventLog>& log,
+uint32_t checkCallHandlerEvents(const std::shared_ptr<EventLog>& log,
                                 uint32_t connId,
                                 EventType callType,
                                 const string& callName) {
@@ -369,7 +369,7 @@
 /**
  * Check for the events that should be after a handler returns.
  */
-void checkCallPostHandlerEvents(const stdcxx::shared_ptr<EventLog>& log,
+void checkCallPostHandlerEvents(const std::shared_ptr<EventLog>& log,
                                 uint32_t connId,
                                 uint32_t callId,
                                 const string& callName) {
@@ -409,7 +409,7 @@
  *
  * Returns the call ID allocated by the server.
  */
-uint32_t checkCallEvents(const stdcxx::shared_ptr<EventLog>& log,
+uint32_t checkCallEvents(const std::shared_ptr<EventLog>& log,
                          uint32_t connId,
                          EventType callType,
                          const string& callName) {
@@ -424,8 +424,8 @@
  */
 
 template <typename State_>
-void testParentService(const stdcxx::shared_ptr<State_>& state) {
-  stdcxx::shared_ptr<typename State_::Client> client = state->createClient();
+void testParentService(const std::shared_ptr<State_>& state) {
+  std::shared_ptr<typename State_::Client> client = state->createClient();
 
   int32_t gen = client->getGeneration();
   int32_t newGen = client->incrementGeneration();
@@ -446,8 +446,8 @@
 }
 
 template <typename State_>
-void testChildService(const stdcxx::shared_ptr<State_>& state) {
-  stdcxx::shared_ptr<typename State_::Client> client = state->createClient();
+void testChildService(const std::shared_ptr<State_>& state) {
+  std::shared_ptr<typename State_::Client> client = state->createClient();
 
   // Test calling some of the parent methids via the a child client
   int32_t gen = client->getGeneration();
@@ -468,7 +468,7 @@
   typedef ServiceState<ServerTraits, ParentServiceTraits<TemplateTraits> > State;
 
   // Start the server
-  stdcxx::shared_ptr<State> state(new State);
+  std::shared_ptr<State> state(new State);
   ServerThread serverThread(state, true);
 
   testParentService(state);
@@ -479,7 +479,7 @@
   typedef ServiceState<ServerTraits, ChildServiceTraits<TemplateTraits> > State;
 
   // Start the server
-  stdcxx::shared_ptr<State> state(new State);
+  std::shared_ptr<State> state(new State);
   ServerThread serverThread(state, true);
 
   testParentService(state);
@@ -502,10 +502,10 @@
                        TBufferedTransport> State;
 
   // Start the server
-  stdcxx::shared_ptr<State> state(new State);
+  std::shared_ptr<State> state(new State);
   ServerThread serverThread(state, true);
 
-  const stdcxx::shared_ptr<EventLog>& log = state->getLog();
+  const std::shared_ptr<EventLog>& log = state->getLog();
 
   // Make sure we're at the end of the log
   checkNoEvents(log);
@@ -514,7 +514,7 @@
 
   // Make sure createContext() is called after a connection has been
   // established.  We open a plain socket instead of creating a client.
-  stdcxx::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", state->getPort()));
+  std::shared_ptr<TSocket> socket(new TSocket("127.0.0.1", state->getPort()));
   socket->open();
 
   // Make sure the proper events occurred after a new connection
@@ -635,19 +635,19 @@
   typedef ServiceState<ServerTraits, ChildServiceTraits<TemplateTraits> > State;
 
   // Start the server
-  stdcxx::shared_ptr<State> state(new State);
+  std::shared_ptr<State> state(new State);
   ServerThread serverThread(state, true);
 
-  const stdcxx::shared_ptr<EventLog>& log = state->getLog();
+  const std::shared_ptr<EventLog>& log = state->getLog();
 
   // Create a client
-  stdcxx::shared_ptr<typename State::Client> client1 = state->createClient();
+  std::shared_ptr<typename State::Client> client1 = state->createClient();
 
   // Make sure the expected events were logged
   uint32_t client1Id = checkNewConnEvents(log);
 
   // Create a second client
-  stdcxx::shared_ptr<typename State::Client> client2 = state->createClient();
+  std::shared_ptr<typename State::Client> client2 = state->createClient();
 
   // Make sure the expected events were logged
   uint32_t client2Id = checkNewConnEvents(log);
@@ -683,13 +683,13 @@
   typedef ServiceState<ServerTraits, ChildServiceTraits<TemplateTraits> > State;
 
   // Start the server
-  stdcxx::shared_ptr<State> state(new State);
+  std::shared_ptr<State> state(new State);
   ServerThread serverThread(state, true);
 
-  const stdcxx::shared_ptr<EventLog>& log = state->getLog();
+  const std::shared_ptr<EventLog>& log = state->getLog();
 
   // Create a client
-  stdcxx::shared_ptr<typename State::Client> client = state->createClient();
+  std::shared_ptr<typename State::Client> client = state->createClient();
   uint32_t connId = checkNewConnEvents(log);
 
   // Make a oneway call
@@ -735,13 +735,13 @@
   typedef ServiceState<ServerTraits, ChildServiceTraits<TemplateTraits> > State;
 
   // Start the server
-  stdcxx::shared_ptr<State> state(new State);
+  std::shared_ptr<State> state(new State);
   ServerThread serverThread(state, true);
 
-  const stdcxx::shared_ptr<EventLog>& log = state->getLog();
+  const std::shared_ptr<EventLog>& log = state->getLog();
 
   // Create a client
-  stdcxx::shared_ptr<typename State::Client> client = state->createClient();
+  std::shared_ptr<typename State::Client> client = state->createClient();
   uint32_t connId = checkNewConnEvents(log);
 
   // Send the exceptionWait() call
@@ -790,13 +790,13 @@
   typedef ServiceState<ServerTraits, ChildServiceTraits<TemplateTraits> > State;
 
   // Start the server
-  stdcxx::shared_ptr<State> state(new State);
+  std::shared_ptr<State> state(new State);
   ServerThread serverThread(state, true);
 
-  const stdcxx::shared_ptr<EventLog>& log = state->getLog();
+  const std::shared_ptr<EventLog>& log = state->getLog();
 
   // Create a client
-  stdcxx::shared_ptr<typename State::Client> client = state->createClient();
+  std::shared_ptr<typename State::Client> client = state->createClient();
   uint32_t connId = checkNewConnEvents(log);
 
   // Send the unexpectedExceptionWait() call
diff --git a/lib/cpp/test/processor/ServerThread.cpp b/lib/cpp/test/processor/ServerThread.cpp
index e752d5e..4d1ec4c 100644
--- a/lib/cpp/test/processor/ServerThread.cpp
+++ b/lib/cpp/test/processor/ServerThread.cpp
@@ -130,7 +130,7 @@
   serverState_->bindSuccessful(port_);
 
   // Set the real server event handler (replacing ourself)
-  stdcxx::shared_ptr<server::TServerEventHandler> serverEventHandler
+  std::shared_ptr<server::TServerEventHandler> serverEventHandler
       = serverState_->getServerEventHandler();
   server_->setServerEventHandler(serverEventHandler);
 
diff --git a/lib/cpp/test/processor/ServerThread.h b/lib/cpp/test/processor/ServerThread.h
index 21c3b60..61e31a3 100644
--- a/lib/cpp/test/processor/ServerThread.h
+++ b/lib/cpp/test/processor/ServerThread.h
@@ -43,7 +43,7 @@
    * If the server returned fails to bind to the specified port when serve() is
    * called on it, createServer() may be called again on a different port.
    */
-  virtual stdcxx::shared_ptr<server::TServer> createServer(uint16_t port) = 0;
+  virtual std::shared_ptr<server::TServer> createServer(uint16_t port) = 0;
 
   /**
    * Get the TServerEventHandler to set on the server.
@@ -52,8 +52,8 @@
    * start serving traffic.  It is invoked from the server thread, rather than
    * the main thread.
    */
-  virtual stdcxx::shared_ptr<server::TServerEventHandler> getServerEventHandler() {
-    return stdcxx::shared_ptr<server::TServerEventHandler>();
+  virtual std::shared_ptr<server::TServerEventHandler> getServerEventHandler() {
+    return std::shared_ptr<server::TServerEventHandler>();
   }
 
   /**
@@ -70,7 +70,7 @@
  */
 class ServerThread {
 public:
-  ServerThread(const stdcxx::shared_ptr<ServerState>& state, bool autoStart)
+  ServerThread(const std::shared_ptr<ServerState>& state, bool autoStart)
     : port_(0),
       running_(false),
       serving_(false),
@@ -116,7 +116,7 @@
   void run();
   void preServe();
 
-  stdcxx::shared_ptr<Helper> helper_;
+  std::shared_ptr<Helper> helper_;
 
   uint16_t port_;
   bool running_;
@@ -124,9 +124,9 @@
   bool error_;
   concurrency::Monitor serverMonitor_;
 
-  stdcxx::shared_ptr<ServerState> serverState_;
-  stdcxx::shared_ptr<server::TServer> server_;
-  stdcxx::shared_ptr<concurrency::Thread> thread_;
+  std::shared_ptr<ServerState> serverState_;
+  std::shared_ptr<server::TServer> server_;
+  std::shared_ptr<concurrency::Thread> thread_;
 };
 }
 }
diff --git a/lib/cpp/test/qt/TQTcpServerTest.cpp b/lib/cpp/test/qt/TQTcpServerTest.cpp
index 8a327aa..58d0c6d 100644
--- a/lib/cpp/test/qt/TQTcpServerTest.cpp
+++ b/lib/cpp/test/qt/TQTcpServerTest.cpp
@@ -8,7 +8,6 @@
 #include <QThread>
 
 #ifndef Q_MOC_RUN
-  #include "thrift/stdcxx.h"
   #include "thrift/protocol/TBinaryProtocol.h"
   #include "thrift/async/TAsyncProcessor.h"
   #include "thrift/qt/TQTcpServer.h"
@@ -21,25 +20,25 @@
 
 struct AsyncHandler : public test::ParentServiceCobSvIf {
   std::vector<std::string> strings;
-  virtual void addString(stdcxx::function<void()> cob, const std::string& s) {
+  virtual void addString(std::function<void()> cob, const std::string& s) {
     strings.push_back(s);
     cob();
   }
-  virtual void getStrings(stdcxx::function<void(std::vector<std::string> const& _return)> cob) {
+  virtual void getStrings(std::function<void(std::vector<std::string> const& _return)> cob) {
     cob(strings);
   }
 
   // Overrides not used in this test
-  virtual void incrementGeneration(stdcxx::function<void(int32_t const& _return)> cob) {}
-  virtual void getGeneration(stdcxx::function<void(int32_t const& _return)> cob) {}
-  virtual void getDataWait(stdcxx::function<void(std::string const& _return)> cob,
+  virtual void incrementGeneration(std::function<void(int32_t const& _return)> cob) {}
+  virtual void getGeneration(std::function<void(int32_t const& _return)> cob) {}
+  virtual void getDataWait(std::function<void(std::string const& _return)> cob,
                            const int32_t length) {}
-  virtual void onewayWait(stdcxx::function<void()> cob) {}
+  virtual void onewayWait(std::function<void()> cob) {}
   virtual void exceptionWait(
-      stdcxx::function<void()> cob,
-      stdcxx::function<void(::apache::thrift::TDelayedException* _throw)> /* exn_cob */,
+      std::function<void()> cob,
+      std::function<void(::apache::thrift::TDelayedException* _throw)> /* exn_cob */,
       const std::string& message) {}
-  virtual void unexpectedExceptionWait(stdcxx::function<void()> cob, const std::string& message) {}
+  virtual void unexpectedExceptionWait(std::function<void()> cob, const std::string& message) {}
 };
 
 class TQTcpServerTest : public QObject {
@@ -51,18 +50,18 @@
   void test_communicate();
 
 private:
-  stdcxx::shared_ptr<QThread> serverThread;
-  stdcxx::shared_ptr<async::TQTcpServer> server;
-  stdcxx::shared_ptr<test::ParentServiceClient> client;
+  std::shared_ptr<QThread> serverThread;
+  std::shared_ptr<async::TQTcpServer> server;
+  std::shared_ptr<test::ParentServiceClient> client;
 };
 
 void TQTcpServerTest::initTestCase() {
   // setup server
-  stdcxx::shared_ptr<QTcpServer> serverSocket = stdcxx::make_shared<QTcpServer>();
+  std::shared_ptr<QTcpServer> serverSocket = std::make_shared<QTcpServer>();
   server.reset(new async::TQTcpServer(serverSocket,
-                                      stdcxx::make_shared<test::ParentServiceAsyncProcessor>(
-                                      stdcxx::make_shared<AsyncHandler>()),
-                                      stdcxx::make_shared<protocol::TBinaryProtocolFactory>()));
+                                      std::make_shared<test::ParentServiceAsyncProcessor>(
+                                      std::make_shared<AsyncHandler>()),
+                                      std::make_shared<protocol::TBinaryProtocolFactory>()));
   QVERIFY(serverSocket->listen(QHostAddress::LocalHost));
   int port = serverSocket->serverPort();
   QVERIFY(port > 0);
@@ -74,9 +73,9 @@
   serverThread->start();
 
   // setup client
-  stdcxx::shared_ptr<QTcpSocket> socket = stdcxx::make_shared<QTcpSocket>();
-  client.reset(new test::ParentServiceClient(stdcxx::make_shared<protocol::TBinaryProtocol>(
-      stdcxx::make_shared<transport::TQIODeviceTransport>(socket))));
+  std::shared_ptr<QTcpSocket> socket = std::make_shared<QTcpSocket>();
+  client.reset(new test::ParentServiceClient(std::make_shared<protocol::TBinaryProtocol>(
+      std::make_shared<transport::TQIODeviceTransport>(socket))));
   socket->connectToHost(QHostAddress::LocalHost, port);
   QVERIFY(socket->waitForConnected());
 }