diff --git a/source/neuropod/backends/neuropod_backend.cc b/source/neuropod/backends/neuropod_backend.cc
index 09df0a3d..8b991293 100644
--- a/source/neuropod/backends/neuropod_backend.cc
+++ b/source/neuropod/backends/neuropod_backend.cc
@@ -219,7 +219,7 @@ NeuropodBackend::NeuropodBackend(const std::string &neuropod_path, RuntimeOption
     : model_config_(load_model_config(neuropod_path)),
       neuropod_path_(neuropod_path),
       options_(std::move(options)),
-      sealer_(stdx::make_unique<Sealer>(get_device_mapping(*model_config_, options_)))
+      sealer_(std::make_unique<Sealer>(get_device_mapping(*model_config_, options_)))
 {
     loader_ = get_loader(neuropod_path);
 }
@@ -301,7 +301,7 @@ std::unique_ptr<NeuropodValueMap> NeuropodBackend::infer_internal(const Neuropod
 
     // Run inference and get all the outputs
     auto data = infer_internal(inputs);
-    auto out  = stdx::make_unique<NeuropodValueMap>();
+    auto out  = std::make_unique<NeuropodValueMap>();
 
     // Filter to the requested outputs
     for (const auto &tensor_name : requested_outputs)
diff --git a/source/neuropod/backends/python_bridge/python_bridge.cc b/source/neuropod/backends/python_bridge/python_bridge.cc
index a01a2191..8064c632 100644
--- a/source/neuropod/backends/python_bridge/python_bridge.cc
+++ b/source/neuropod/backends/python_bridge/python_bridge.cc
@@ -165,7 +165,7 @@ std::unique_ptr<py::gil_scoped_release> maybe_initialize()
 
     // TODO: shutdown the interpreter once we know that there are no more python objects left
     // atexit(py::finalize_interpreter);
-    return stdx::make_unique<py::gil_scoped_release>();
+    return std::make_unique<py::gil_scoped_release>();
 }
 
 // Handle interpreter startup and shutdown
@@ -205,7 +205,7 @@ void PythonBridge::load_model_internal()
     const auto local_path = loader_->ensure_local();
 
     // Load the neuropod and save a reference to it
-    neuropod_ = stdx::make_unique<py::object>(load_neuropod(local_path));
+    neuropod_ = std::make_unique<py::object>(load_neuropod(local_path));
 }
 
 PythonBridge::~PythonBridge()
@@ -249,7 +249,7 @@ std::unique_ptr<NeuropodValueMap> PythonBridge::infer_internal(const NeuropodVal
     auto outputs = from_numpy_dict(*get_tensor_allocator(), model_outputs);
 
     // We need a unique pointer
-    return stdx::make_unique<NeuropodValueMap>(std::move(outputs));
+    return std::make_unique<NeuropodValueMap>(std::move(outputs));
 }
 
 REGISTER_NEUROPOD_BACKEND(PythonBridge, "python", PY_VERSION)
diff --git a/source/neuropod/backends/tensorflow/tf_backend.cc b/source/neuropod/backends/tensorflow/tf_backend.cc
index 2a85fe7f..523cb351 100644
--- a/source/neuropod/backends/tensorflow/tf_backend.cc
+++ b/source/neuropod/backends/tensorflow/tf_backend.cc
@@ -385,7 +385,7 @@ std::unique_ptr<NeuropodValueMap> TensorflowNeuropodBackend::infer_internal(
     check_tf_status(session_->RunCallable(handle, tf_inputs, &outputs, nullptr));
 
     // Read the outputs and wrap them in `NeuropodTensor`s
-    auto   to_return = stdx::make_unique<NeuropodValueMap>();
+    auto   to_return = std::make_unique<NeuropodValueMap>();
     size_t position  = 0;
     for (const auto &item : tensor_fetches)
     {
diff --git a/source/neuropod/backends/torchscript/torch_backend.cc b/source/neuropod/backends/torchscript/torch_backend.cc
index e84029d2..fa8161d6 100644
--- a/source/neuropod/backends/torchscript/torch_backend.cc
+++ b/source/neuropod/backends/torchscript/torch_backend.cc
@@ -171,7 +171,7 @@ void insert_value_in_output(NeuropodValueMap & output,
             (!has_type && list[0].isString()))
         {
             // Make a TorchNeuropodTensor
-            auto neuropod_tensor = stdx::make_unique<TorchNeuropodTensor<std::string>>(tensor);
+            auto neuropod_tensor = std::make_unique<TorchNeuropodTensor<std::string>>(tensor);
 
             // Add it to our output
             auto &to_set = output[name];
@@ -416,7 +416,7 @@ std::unique_ptr<NeuropodValueMap> TorchNeuropodBackend::infer_internal(const Neu
     c10::IValue result = model_->forward(torch_inputs);
 
     // Get outputs
-    auto to_return = stdx::make_unique<NeuropodValueMap>();
+    auto to_return = std::make_unique<NeuropodValueMap>();
 
     if (result.isGenericDict())
     {
diff --git a/source/neuropod/bindings/neuropod_native.cc b/source/neuropod/bindings/neuropod_native.cc
index 910dcc81..648a4d62 100644
--- a/source/neuropod/bindings/neuropod_native.cc
+++ b/source/neuropod/bindings/neuropod_native.cc
@@ -144,7 +144,7 @@ template <typename... Params>
 std::unique_ptr<Neuropod> make_neuropod(py::kwargs kwargs, Params &&... params)
 {
     auto options = get_options_from_kwargs(kwargs);
-    return stdx::make_unique<Neuropod>(std::forward<Params>(params)..., options);
+    return std::make_unique<Neuropod>(std::forward<Params>(params)..., options);
 }
 
 } // namespace
diff --git a/source/neuropod/core/generic_tensor.cc b/source/neuropod/core/generic_tensor.cc
index 46e4253b..379eca31 100644
--- a/source/neuropod/core/generic_tensor.cc
+++ b/source/neuropod/core/generic_tensor.cc
@@ -25,7 +25,7 @@ namespace neuropod
 
 std::unique_ptr<NeuropodTensorAllocator> get_generic_tensor_allocator()
 {
-    return stdx::make_unique<DefaultTensorAllocator<GenericNeuropodTensor>>();
+    return std::make_unique<DefaultTensorAllocator<GenericNeuropodTensor>>();
 }
 
 } // namespace neuropod
diff --git a/source/neuropod/internal/backend_registration.cc b/source/neuropod/internal/backend_registration.cc
index 31359b52..00d80b90 100644
--- a/source/neuropod/internal/backend_registration.cc
+++ b/source/neuropod/internal/backend_registration.cc
@@ -46,7 +46,7 @@ std::unique_ptr<std::unordered_map<std::string, BackendInfo>> registered_backend
 void init_registrar_if_needed()
 {
     std::call_once(registrar_initialized, []() {
-        registered_backends_by_type = stdx::make_unique<std::unordered_map<std::string, BackendInfo>>();
+        registered_backends_by_type = std::make_unique<std::unordered_map<std::string, BackendInfo>>();
 
         // Make sure our logging is initialized
         init_logging();
diff --git a/source/neuropod/internal/backend_registration.hh b/source/neuropod/internal/backend_registration.hh
index 9b6ede67..0e521e21 100644
--- a/source/neuropod/internal/backend_registration.hh
+++ b/source/neuropod/internal/backend_registration.hh
@@ -38,7 +38,7 @@ typedef std::unique_ptr<NeuropodBackend> (*BackendFactoryFunction)(const std::st
 template <typename T>
 std::unique_ptr<NeuropodBackend> createNeuropodBackend(const std::string &neuropod_path, const RuntimeOptions &options)
 {
-    return stdx::make_unique<T>(neuropod_path, options);
+    return std::make_unique<T>(neuropod_path, options);
 }
 
 // Register a backend for a set of specific types
diff --git a/source/neuropod/internal/config_utils.cc b/source/neuropod/internal/config_utils.cc
index 8414fd94..26d2603e 100644
--- a/source/neuropod/internal/config_utils.cc
+++ b/source/neuropod/internal/config_utils.cc
@@ -264,7 +264,7 @@ std::unique_ptr<ModelConfig> load_model_config(std::istream &input_stream)
     }
 
     // Not directly using make_unique because of brace initialization
-    return stdx::make_unique<ModelConfig>(
+    return std::make_unique<ModelConfig>(
         ModelConfig{name, platform, platform_version_semver, inputs, outputs, custom_ops, input_tensor_device});
 }
 
diff --git a/source/neuropod/internal/config_utils.hh b/source/neuropod/internal/config_utils.hh
index 2e33ff5f..a31ac18e 100644
--- a/source/neuropod/internal/config_utils.hh
+++ b/source/neuropod/internal/config_utils.hh
@@ -15,7 +15,6 @@ limitations under the License.
 
 #pragma once
 
-#include "neuropod/internal/memory_utils.hh"
 #include "neuropod/internal/tensor_types.hh"
 
 #include <memory>
diff --git a/source/neuropod/internal/memory_utils.hh b/source/neuropod/internal/memory_utils.hh
deleted file mode 100644
index 9fcc0cc6..00000000
--- a/source/neuropod/internal/memory_utils.hh
+++ /dev/null
@@ -1,65 +0,0 @@
-/* Copyright (c) 2020 The Neuropod Authors
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#pragma once
-
-#include <memory>
-#include <utility>
-
-namespace neuropod
-{
-namespace stdx
-{
-namespace detail
-{
-
-template <typename T>
-struct unique_if
-{
-    using unique_ptr = std::unique_ptr<T>;
-};
-
-template <typename T>
-struct unique_if<T[]>
-{
-    using unique_ptr_array_unknown_bound = std::unique_ptr<T[]>;
-};
-
-template <typename T, std::size_t N>
-struct unique_if<T[N]>
-{
-    using unique_ptr_array_known_bound = void;
-};
-
-} // namespace detail
-
-// See http://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique
-template <typename T, typename... Args>
-typename detail::unique_if<T>::unique_ptr make_unique(Args &&... args)
-{
-    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-}
-
-template <typename T>
-typename detail::unique_if<T>::unique_ptr_array_unknown_bound make_unique(std::size_t n)
-{
-    return std::unique_ptr<T>(new typename std::remove_extent<T>::type[n]());
-}
-
-template <typename T, typename... Args>
-typename detail::unique_if<T>::unique_ptr_array_known_bound make_unique(Args &&...) = delete;
-
-} // namespace stdx
-} // namespace neuropod
diff --git a/source/neuropod/internal/neuropod_loader.cc b/source/neuropod/internal/neuropod_loader.cc
index ba3a0235..4d5c1b33 100644
--- a/source/neuropod/internal/neuropod_loader.cc
+++ b/source/neuropod/internal/neuropod_loader.cc
@@ -48,7 +48,7 @@ class LocalLoader : public NeuropodLoader
 
     std::unique_ptr<std::istream> get_istream_for_file(const std::string &path) override
     {
-        auto ret = stdx::make_unique<std::ifstream>(get_file_path(path));
+        auto ret = std::make_unique<std::ifstream>(get_file_path(path));
         if (!(*ret))
         {
             return nullptr;
@@ -99,7 +99,7 @@ class ZipLoader : public NeuropodLoader
 
     std::unique_ptr<std::istream> get_istream_for_file(const std::string &path) override
     {
-        auto out = stdx::make_unique<std::stringstream>();
+        auto out = std::make_unique<std::stringstream>();
         if (!unzipper_.extractEntryToStream(path, *out))
         {
             return nullptr;
@@ -174,10 +174,10 @@ std::unique_ptr<NeuropodLoader> get_loader(const std::string &neuropod_path)
 
     if (fs::is_directory(neuropod_path))
     {
-        return stdx::make_unique<LocalLoader>(neuropod_path);
+        return std::make_unique<LocalLoader>(neuropod_path);
     }
 
-    return stdx::make_unique<ZipLoader>(neuropod_path);
+    return std::make_unique<ZipLoader>(neuropod_path);
 }
 
 } // namespace neuropod
diff --git a/source/neuropod/internal/neuropod_tensor.hh b/source/neuropod/internal/neuropod_tensor.hh
index 3ecbb11a..e5c777eb 100644
--- a/source/neuropod/internal/neuropod_tensor.hh
+++ b/source/neuropod/internal/neuropod_tensor.hh
@@ -644,7 +644,7 @@ protected:
 // Utility to make a tensor of a specific type
 #define MAKE_TENSOR(CPP_TYPE, NEUROPOD_TYPE)                                              \
     case NEUROPOD_TYPE: {                                                                 \
-        return stdx::make_unique<TensorClass<CPP_TYPE>>(std::forward<Params>(params)...); \
+        return std::make_unique<TensorClass<CPP_TYPE>>(std::forward<Params>(params)...); \
     }
 
 template <template <class> class TensorClass, typename... Params>
diff --git a/source/neuropod/multiprocess/mq/ipc_message_queue_impl.hh b/source/neuropod/multiprocess/mq/ipc_message_queue_impl.hh
index 22756f1b..9d37a2e9 100644
--- a/source/neuropod/multiprocess/mq/ipc_message_queue_impl.hh
+++ b/source/neuropod/multiprocess/mq/ipc_message_queue_impl.hh
@@ -34,7 +34,7 @@ constexpr auto MAX_QUEUE_SIZE = 20;
 template <typename UserPayloadType>
 inline std::unique_ptr<ipc::message_queue> make_queue(const std::string &control_queue_name_, const std::string &suffix)
 {
-    return stdx::make_unique<ipc::message_queue>(ipc::open_or_create,
+    return std::make_unique<ipc::message_queue>(ipc::open_or_create,
                                                  ("neuropod_" + control_queue_name_ + suffix).c_str(),
                                                  MAX_QUEUE_SIZE,
                                                  sizeof(WireFormat<UserPayloadType>));
@@ -67,7 +67,7 @@ void IPCMessageQueue<UserPayloadType>::read_worker_loop()
                           boost::posix_time::milliseconds(detail::MESSAGE_TIMEOUT_MS);
 
         // Get a message
-        auto         received = stdx::make_unique<WireFormat>();
+        auto         received = std::make_unique<WireFormat>();
         size_t       received_size;
         unsigned int priority;
         bool         successful_read =
@@ -196,8 +196,8 @@ IPCMessageQueue<UserPayloadType>::IPCMessageQueue(const std::string &control_que
       control_queue_name_(control_queue_name),
       send_queue_(detail::make_send_queue<UserPayloadType>(control_queue_name_, type)),
       recv_queue_(detail::make_recv_queue<UserPayloadType>(control_queue_name_, type)),
-      heartbeat_controller_(stdx::make_unique<detail::HeartbeatController>(*this)),
-      transferrable_controller_(stdx::make_unique<detail::TransferrableController>()),
+      heartbeat_controller_(std::make_unique<detail::HeartbeatController>(*this)),
+      transferrable_controller_(std::make_unique<detail::TransferrableController>()),
       lost_heartbeat_(false),
       read_worker_(&IPCMessageQueue<UserPayloadType>::read_worker_loop, this)
 {
diff --git a/source/neuropod/multiprocess/mq/test/test_ipc_message_queue.cc b/source/neuropod/multiprocess/mq/test/test_ipc_message_queue.cc
index e3a58d7c..e86bfeb7 100644
--- a/source/neuropod/multiprocess/mq/test/test_ipc_message_queue.cc
+++ b/source/neuropod/multiprocess/mq/test/test_ipc_message_queue.cc
@@ -27,7 +27,7 @@ TEST(test_ipc_message_queue, simple)
     {
         // A tensor allocator that allocates tensors in shared memory
         std::unique_ptr<neuropod::NeuropodTensorAllocator> allocator =
-            neuropod::stdx::make_unique<neuropod::DefaultTensorAllocator<neuropod::SHMNeuropodTensor>>();
+            neuropod::std::make_unique<neuropod::DefaultTensorAllocator<neuropod::SHMNeuropodTensor>>();
 
         // Store tensors we allocate so they don't go out of scope
         neuropod::NeuropodValueMap sender_map;
diff --git a/source/neuropod/multiprocess/mq/test/test_ope_heartbeat.cc b/source/neuropod/multiprocess/mq/test/test_ope_heartbeat.cc
index 1fcfd902..96b91c5e 100644
--- a/source/neuropod/multiprocess/mq/test/test_ope_heartbeat.cc
+++ b/source/neuropod/multiprocess/mq/test/test_ope_heartbeat.cc
@@ -59,7 +59,7 @@ class TestChannel
 
 TEST(test_ope_heartbeat, basic)
 {
-    auto test_channel = neuropod::stdx::make_unique<TestChannel>();
+    auto test_channel = neuropod::std::make_unique<TestChannel>();
 
     // Create a controller
     neuropod::detail::HeartbeatController controller(*test_channel);
diff --git a/source/neuropod/multiprocess/multiprocess.cc b/source/neuropod/multiprocess/multiprocess.cc
index 044ab1fe..a44c7ffb 100644
--- a/source/neuropod/multiprocess/multiprocess.cc
+++ b/source/neuropod/multiprocess/multiprocess.cc
@@ -271,7 +271,7 @@ class MultiprocessNeuropodBackend : public NeuropodBackendWithDefaultAllocator<S
         }
 
         // Load the returned tensors
-        auto to_return = stdx::make_unique<NeuropodValueMap>();
+        auto to_return = std::make_unique<NeuropodValueMap>();
         received.get(*to_return);
 
         if (free_memory_every_cycle_)
@@ -309,7 +309,7 @@ std::unique_ptr<NeuropodBackend> load_neuropod_ope(const std::string &
     if (control_queue_name.empty())
     {
         // Start a new worker
-        return stdx::make_unique<MultiprocessNeuropodBackend>(
+        return std::make_unique<MultiprocessNeuropodBackend>(
             neuropod_path, options, free_memory_every_cycle, default_backend_overrides);
     }
 
@@ -321,7 +321,7 @@ std::unique_ptr<NeuropodBackend> load_neuropod_ope(const std::string &
     }
 
     // Use an existing worker
-    return stdx::make_unique<MultiprocessNeuropodBackend>(neuropod_path, control_queue_name, free_memory_every_cycle);
+    return std::make_unique<MultiprocessNeuropodBackend>(neuropod_path, control_queue_name, free_memory_every_cycle);
 }
 
 } // namespace neuropod
diff --git a/source/neuropod/multiprocess/multiprocess_worker.cc b/source/neuropod/multiprocess/multiprocess_worker.cc
index e7070e6c..fcc2948c 100644
--- a/source/neuropod/multiprocess/multiprocess_worker.cc
+++ b/source/neuropod/multiprocess/multiprocess_worker.cc
@@ -63,7 +63,7 @@ void multiprocess_worker_loop(const std::string &control_queue_name)
                 opts.use_ope                    = false;
 
                 // Load a neuropod
-                neuropod  = stdx::make_unique<Neuropod>(config.neuropod_path, config.default_backend_overrides, opts);
+                neuropod  = std::make_unique<Neuropod>(config.neuropod_path, config.default_backend_overrides, opts);
                 allocator = neuropod->get_tensor_allocator();
                 inputs.clear();
                 control_channel.send_message(LOAD_SUCCESS);
diff --git a/source/neuropod/multiprocess/serialization/ipc_serialization.hh b/source/neuropod/multiprocess/serialization/ipc_serialization.hh
index 4f6582c9..e3c75cfe 100644
--- a/source/neuropod/multiprocess/serialization/ipc_serialization.hh
+++ b/source/neuropod/multiprocess/serialization/ipc_serialization.hh
@@ -151,7 +151,7 @@ inline void ipc_deserialize(std::istream &in, std::string &item)
     else
     {
         // We need to allocate a larger buffer
-        auto buffer = stdx::make_unique<char[]>(length);
+        auto buffer = std::make_unique<char[]>(length);
         detail::checked_read(in, buffer.get(), length);
 
         // Set the content of `item`
diff --git a/source/neuropod/multiprocess/serialization/test/test_ipc_serialization.cc b/source/neuropod/multiprocess/serialization/test/test_ipc_serialization.cc
index 5a2772b6..7c0bface 100644
--- a/source/neuropod/multiprocess/serialization/test/test_ipc_serialization.cc
+++ b/source/neuropod/multiprocess/serialization/test/test_ipc_serialization.cc
@@ -89,7 +89,7 @@ TEST(test_ipc_serialization, neuropod_value_map)
 {
     // A tensor allocator that allocates tensors in shared memory
     std::unique_ptr<neuropod::NeuropodTensorAllocator> allocator =
-        neuropod::stdx::make_unique<neuropod::DefaultTensorAllocator<neuropod::SHMNeuropodTensor>>();
+        neuropod::std::make_unique<neuropod::DefaultTensorAllocator<neuropod::SHMNeuropodTensor>>();
 
     const std::shared_ptr<neuropod::NeuropodValue> float_tensor_1D =
         allocator->allocate_tensor({3}, neuropod::FLOAT_TENSOR);
diff --git a/source/neuropod/multiprocess/shm/raw_shm_block_allocator.cc b/source/neuropod/multiprocess/shm/raw_shm_block_allocator.cc
index 90323060..2f5fd63c 100644
--- a/source/neuropod/multiprocess/shm/raw_shm_block_allocator.cc
+++ b/source/neuropod/multiprocess/shm/raw_shm_block_allocator.cc
@@ -98,14 +98,14 @@ class RawSHMBlock
         : uuid_(uuid_generator())
     {
         // Create a block of shared memory
-        shm_ = stdx::make_unique<ipc::shared_memory_object>(
+        shm_ = std::make_unique<ipc::shared_memory_object>(
             ipc::create_only, get_key_from_uuid(uuid_).c_str(), ipc::read_write);
 
         // Set the size
         shm_->truncate(sizeof(RawSHMBlockInternal) + size_bytes);
 
         // Map into memory
-        region_ = stdx::make_unique<ipc::mapped_region>(*shm_, ipc::read_write);
+        region_ = std::make_unique<ipc::mapped_region>(*shm_, ipc::read_write);
 
         // Get a pointer to the struct and initialize it
         block_ = new (region_->get_address()) RawSHMBlockInternal;
@@ -125,10 +125,10 @@ class RawSHMBlock
         const auto shm_key = get_key_from_uuid(uuid_);
 
         // Load a chunk of shared memory
-        shm_ = stdx::make_unique<ipc::shared_memory_object>(ipc::open_only, shm_key.c_str(), ipc::read_write);
+        shm_ = std::make_unique<ipc::shared_memory_object>(ipc::open_only, shm_key.c_str(), ipc::read_write);
 
         // Map into memory
-        region_ = stdx::make_unique<ipc::mapped_region>(*shm_, ipc::read_write);
+        region_ = std::make_unique<ipc::mapped_region>(*shm_, ipc::read_write);
 
         // Get a pointer to the struct
         block_ = static_cast<RawSHMBlockInternal *>(region_->get_address());
diff --git a/source/neuropod/multiprocess/shm/shm_allocator.cc b/source/neuropod/multiprocess/shm/shm_allocator.cc
index 3daa6476..c6b4773c 100644
--- a/source/neuropod/multiprocess/shm/shm_allocator.cc
+++ b/source/neuropod/multiprocess/shm/shm_allocator.cc
@@ -189,7 +189,7 @@ class AllocationCache
 };
 
 SHMAllocator::SHMAllocator()
-    : allocation_cache_(stdx::make_unique<AllocationCache>()), load_cache_(stdx::make_unique<LoadCache>())
+    : allocation_cache_(std::make_unique<AllocationCache>()), load_cache_(std::make_unique<LoadCache>())
 {
 }
 
diff --git a/source/neuropod/multiprocess/shm_tensor.hh b/source/neuropod/multiprocess/shm_tensor.hh
index bc19c54a..4b03008f 100644
--- a/source/neuropod/multiprocess/shm_tensor.hh
+++ b/source/neuropod/multiprocess/shm_tensor.hh
@@ -192,7 +192,7 @@ public:
                       const SHMBlockID &          block_id)
         : TypedNeuropodTensor<std::string>(copy_and_strip_last_dim(dims)), write_buffer_(this->get_num_elements())
     {
-        auto byte_block = stdx::make_unique<SHMNeuropodTensor<uint8_t>>(dims, std::move(block), data, block_id);
+        auto byte_block = std::make_unique<SHMNeuropodTensor<uint8_t>>(dims, std::move(block), data, block_id);
 
         auto base_ptr = byte_block->get_raw_data_ptr();
         auto max_len  = dims[dims.size() - 1];
@@ -229,7 +229,7 @@ public:
         dims_copy.push_back(max_len);
 
         // TODO(vip): We can optimize this
-        last_shm_block_ = stdx::make_unique<SHMNeuropodTensor<uint8_t>>(dims_copy);
+        last_shm_block_ = std::make_unique<SHMNeuropodTensor<uint8_t>>(dims_copy);
         last_shm_block_->overwrite_type(STRING_TENSOR);
 
         // Copy data in
diff --git a/source/neuropod/multiprocess/test/benchmark_multiprocess.cc b/source/neuropod/multiprocess/test/benchmark_multiprocess.cc
index 6ab1bf14..2c38cf77 100644
--- a/source/neuropod/multiprocess/test/benchmark_multiprocess.cc
+++ b/source/neuropod/multiprocess/test/benchmark_multiprocess.cc
@@ -26,7 +26,7 @@ struct load_in_process
 {
     std::unique_ptr<neuropod::Neuropod> operator()(const std::string &path)
     {
-        return neuropod::stdx::make_unique<neuropod::Neuropod>(path);
+        return neuropod::std::make_unique<neuropod::Neuropod>(path);
     }
 };
 
@@ -36,7 +36,7 @@ struct load_out_of_process
     {
         neuropod::RuntimeOptions opts;
         opts.use_ope = true;
-        return neuropod::stdx::make_unique<neuropod::Neuropod>(path, opts);
+        return neuropod::std::make_unique<neuropod::Neuropod>(path, opts);
     }
 };
 
diff --git a/source/neuropod/multiprocess/test/test_ipc_control_channel.cc b/source/neuropod/multiprocess/test/test_ipc_control_channel.cc
index 198cd945..e88506c4 100644
--- a/source/neuropod/multiprocess/test/test_ipc_control_channel.cc
+++ b/source/neuropod/multiprocess/test/test_ipc_control_channel.cc
@@ -21,7 +21,7 @@ TEST(test_ipc_control_channel, simple)
 {
     // A tensor allocator that allocates tensors in shared memory
     std::unique_ptr<neuropod::NeuropodTensorAllocator> allocator =
-        neuropod::stdx::make_unique<neuropod::DefaultTensorAllocator<neuropod::SHMNeuropodTensor>>();
+        neuropod::std::make_unique<neuropod::DefaultTensorAllocator<neuropod::SHMNeuropodTensor>>();
 
     // Store tensors we allocate so they don't go out of scope
     neuropod::NeuropodValueMap sender_map;
diff --git a/source/neuropod/multiprocess/test/test_shm_tensor.cc b/source/neuropod/multiprocess/test/test_shm_tensor.cc
index 4f55280b..7651c510 100644
--- a/source/neuropod/multiprocess/test/test_shm_tensor.cc
+++ b/source/neuropod/multiprocess/test/test_shm_tensor.cc
@@ -20,7 +20,7 @@ TEST(test_shm_tensor, simple)
 {
     // A tensor allocator that allocates tensors in shared memory
     std::unique_ptr<neuropod::NeuropodTensorAllocator> allocator =
-        neuropod::stdx::make_unique<neuropod::DefaultTensorAllocator<neuropod::SHMNeuropodTensor>>();
+        neuropod::std::make_unique<neuropod::DefaultTensorAllocator<neuropod::SHMNeuropodTensor>>();
 
     // Store tensors we allocate so they don't go out of scope
     std::vector<std::shared_ptr<neuropod::NeuropodTensor>> items;
diff --git a/source/neuropod/serialization/serialization.cc b/source/neuropod/serialization/serialization.cc
index 3044fa2e..b00740b5 100644
--- a/source/neuropod/serialization/serialization.cc
+++ b/source/neuropod/serialization/serialization.cc
@@ -33,8 +33,8 @@ std::unique_ptr<std::unordered_map<std::string, deserialize_fn_t>> registered_de
 void init_registrar_if_needed()
 {
     std::call_once(registrar_initialized, []() {
-        registered_serializers   = stdx::make_unique<std::unordered_map<std::string, serialize_fn_t>>();
-        registered_deserializers = stdx::make_unique<std::unordered_map<std::string, deserialize_fn_t>>();
+        registered_serializers   = std::make_unique<std::unordered_map<std::string, serialize_fn_t>>();
+        registered_deserializers = std::make_unique<std::unordered_map<std::string, deserialize_fn_t>>();
     });
 }