diff --git a/include/openmc/mesh.h b/include/openmc/mesh.h
index 2e16ed22a..eca32ad4a 100644
--- a/include/openmc/mesh.h
+++ b/include/openmc/mesh.h
@@ -370,11 +370,8 @@ public:
                     vector<int>& bins,
                     vector<double>& lengths) const override;
 
-  void
-  surface_bins_crossed(Position r0,
-                       Position r1,
-                       const Direction& u,
-                       std::vector<int>& bins) const override;
+  void surface_bins_crossed(Position r0, Position r1, const Direction& u,
+    vector<int>& bins) const override;
 
   int get_bin(Position r) const;
 
@@ -522,11 +519,8 @@ public:
                     vector<int>& bins,
                     vector<double>& lengths) const override;
 
-  void
-  surface_bins_crossed(Position r0,
-                       Position r1,
-                       const Direction& u,
-                       std::vector<int>& bins) const override;
+  void surface_bins_crossed(Position r0, Position r1, const Direction& u,
+    vector<int>& bins) const override;
 
   int get_bin(Position r) const override;
 
diff --git a/src/cell.cpp b/src/cell.cpp
index 44d960707..6b88a6780 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -999,7 +999,7 @@ void read_cells(pugi::xml_node node)
   // Loop over XML cell elements and populate the array.
   model::cells.reserve(n_cells);
   for (pugi::xml_node cell_node : node.children("cell")) {
-    model::cells.push_back(std::make_unique<CSGCell>(cell_node));
+    model::cells.push_back(make_unique<CSGCell>(cell_node));
   }
 
   // Fill the cell map.
@@ -1018,7 +1018,7 @@ void read_cells(pugi::xml_node node)
     int32_t uid = model::cells[i]->universe_;
     auto it = model::universe_map.find(uid);
     if (it == model::universe_map.end()) {
-      model::universes.push_back(std::make_unique<Universe>());
+      model::universes.push_back(make_unique<Universe>());
       model::universes.back()->id_ = uid;
       model::universes.back()->cells_.push_back(i);
       model::universe_map[uid] = model::universes.size() - 1;
@@ -1285,7 +1285,7 @@ openmc_extend_cells(int32_t n, int32_t* index_start, int32_t* index_end)
   if (index_start) *index_start = model::cells.size();
   if (index_end) *index_end = model::cells.size() + n - 1;
   for (int32_t i = 0; i < n; i++) {
-    model::cells.push_back(std::make_unique<CSGCell>());
+    model::cells.push_back(make_unique<CSGCell>());
   }
   return 0;
 }
diff --git a/src/cross_sections.cpp b/src/cross_sections.cpp
index 506f6af52..ea8d0cfbb 100644
--- a/src/cross_sections.cpp
+++ b/src/cross_sections.cpp
@@ -236,8 +236,8 @@ void read_ce_cross_sections(const vector<vector<double>>& nuc_temps,
 
         // Read thermal scattering data from HDF5
         hid_t group = open_group(file_id, name.c_str());
-        data::thermal_scatt.push_back(std::make_unique<ThermalScattering>(
-          group, thermal_temps[i_table]));
+        data::thermal_scatt.push_back(
+          make_unique<ThermalScattering>(group, thermal_temps[i_table]));
         close_group(group);
         file_close(file_id);
 
diff --git a/src/dagmc.cpp b/src/dagmc.cpp
index 74d5a56bd..0c2768834 100644
--- a/src/dagmc.cpp
+++ b/src/dagmc.cpp
@@ -211,7 +211,7 @@ void load_dagmc_geometry()
     // Populate the Universe vector and dict
     auto it = model::universe_map.find(dagmc_univ_id);
     if (it == model::universe_map.end()) {
-      model::universes.push_back(std::make_unique<Universe>());
+      model::universes.push_back(make_unique<Universe>());
       model::universes.back()->id_ = dagmc_univ_id;
       model::universes.back()->cells_.push_back(i);
       model::universe_map[dagmc_univ_id] = model::universes.size() - 1;
diff --git a/src/distribution_spatial.cpp b/src/distribution_spatial.cpp
index 125d8afa6..356383eb7 100644
--- a/src/distribution_spatial.cpp
+++ b/src/distribution_spatial.cpp
@@ -65,7 +65,7 @@ CylindricalIndependent::CylindricalIndependent(pugi::xml_node node)
     // If no distribution was specified, default to a single point at r=0
     double x[] {0.0};
     double p[] {1.0};
-    r_ = std::make_unique<Discrete>(x, p, 1);
+    r_ = make_unique<Discrete>(x, p, 1);
   }
 
   // Read distribution for phi-coordinate
@@ -76,7 +76,7 @@ CylindricalIndependent::CylindricalIndependent(pugi::xml_node node)
     // If no distribution was specified, default to a single point at phi=0
     double x[] {0.0};
     double p[] {1.0};
-    phi_ = std::make_unique<Discrete>(x, p, 1);
+    phi_ = make_unique<Discrete>(x, p, 1);
   }
 
   // Read distribution for z-coordinate
@@ -87,7 +87,7 @@ CylindricalIndependent::CylindricalIndependent(pugi::xml_node node)
     // If no distribution was specified, default to a single point at z=0
     double x[] {0.0};
     double p[] {1.0};
-    z_ = std::make_unique<Discrete>(x, p, 1);
+    z_ = make_unique<Discrete>(x, p, 1);
   }
 
   // Read cylinder center coordinates
@@ -129,7 +129,7 @@ SphericalIndependent::SphericalIndependent(pugi::xml_node node)
     // If no distribution was specified, default to a single point at r=0
     double x[] {0.0};
     double p[] {1.0};
-    r_ = std::make_unique<Discrete>(x, p, 1);
+    r_ = make_unique<Discrete>(x, p, 1);
   }
 
   // Read distribution for theta-coordinate
@@ -140,7 +140,7 @@ SphericalIndependent::SphericalIndependent(pugi::xml_node node)
     // If no distribution was specified, default to a single point at theta=0
     double x[] {0.0};
     double p[] {1.0};
-    theta_ = std::make_unique<Discrete>(x, p, 1);
+    theta_ = make_unique<Discrete>(x, p, 1);
   }
 
   // Read distribution for phi-coordinate
@@ -151,7 +151,7 @@ SphericalIndependent::SphericalIndependent(pugi::xml_node node)
     // If no distribution was specified, default to a single point at phi=0
     double x[] {0.0};
     double p[] {1.0};
-    phi_ = std::make_unique<Discrete>(x, p, 1);
+    phi_ = make_unique<Discrete>(x, p, 1);
   }
 
   // Read sphere center coordinates
diff --git a/src/endf.cpp b/src/endf.cpp
index 53df401c9..eb7e00e28 100644
--- a/src/endf.cpp
+++ b/src/endf.cpp
@@ -84,13 +84,13 @@ unique_ptr<Function1D> read_function(hid_t group, const char* name)
   read_attribute(dset, "type", func_type);
   unique_ptr<Function1D> func;
   if (func_type == "Tabulated1D") {
-    func = std::make_unique<Tabulated1D>(dset);
+    func = make_unique<Tabulated1D>(dset);
   } else if (func_type == "Polynomial") {
-    func = std::make_unique<Polynomial>(dset);
+    func = make_unique<Polynomial>(dset);
   } else if (func_type == "CoherentElastic") {
-    func = std::make_unique<CoherentElasticXS>(dset);
+    func = make_unique<CoherentElasticXS>(dset);
   } else if (func_type == "IncoherentElastic") {
-    func = std::make_unique<IncoherentElasticXS>(dset);
+    func = make_unique<IncoherentElasticXS>(dset);
   } else {
     throw std::runtime_error{"Unknown function type " + func_type +
       " for dataset " + object_name(dset)};
diff --git a/src/geometry_aux.cpp b/src/geometry_aux.cpp
index f7eaac99d..17000129d 100644
--- a/src/geometry_aux.cpp
+++ b/src/geometry_aux.cpp
@@ -157,7 +157,7 @@ partition_universes()
         if (dynamic_cast<const SurfaceZPlane*>(model::surfaces[i_surf].get())) {
           ++n_zplanes;
           if (n_zplanes > 5) {
-            univ->partitioner_ = std::make_unique<UniversePartitioner>(*univ);
+            univ->partitioner_ = make_unique<UniversePartitioner>(*univ);
             break;
           }
         }
diff --git a/src/initialize.cpp b/src/initialize.cpp
index e22367d81..c6a432d12 100644
--- a/src/initialize.cpp
+++ b/src/initialize.cpp
@@ -74,10 +74,12 @@ if (!settings::libmesh_init && !libMesh::initialized()) {
   // pass command line args, empty MPI communicator, and number of threads.
   // Because libMesh was not initialized, we assume that OpenMC is the primary
   // application and that its main MPI comm should be used.
-  settings::libmesh_init = std::make_unique<libMesh::LibMeshInit>(argc, argv, comm, n_threads);
+  settings::libmesh_init =
+    make_unique<libMesh::LibMeshInit>(argc, argv, comm, n_threads);
 #else
   // pass command line args, empty MPI communicator, and number of threads
-  settings::libmesh_init = std::make_unique<libMesh::LibMeshInit>(argc, argv, 0, n_threads);
+  settings::libmesh_init =
+    make_unique<libMesh::LibMeshInit>(argc, argv, 0, n_threads);
 #endif
 
   settings::libmesh_comm = &(settings::libmesh_init->comm());
diff --git a/src/lattice.cpp b/src/lattice.cpp
index d7f5a941e..ee102eb3b 100644
--- a/src/lattice.cpp
+++ b/src/lattice.cpp
@@ -1055,10 +1055,10 @@ HexLattice::to_hdf5_inner(hid_t lat_group) const
 void read_lattices(pugi::xml_node node)
 {
   for (pugi::xml_node lat_node : node.children("lattice")) {
-    model::lattices.push_back(std::make_unique<RectLattice>(lat_node));
+    model::lattices.push_back(make_unique<RectLattice>(lat_node));
   }
   for (pugi::xml_node lat_node : node.children("hex_lattice")) {
-    model::lattices.push_back(std::make_unique<HexLattice>(lat_node));
+    model::lattices.push_back(make_unique<HexLattice>(lat_node));
   }
 
   // Fill the lattice map.
diff --git a/src/material.cpp b/src/material.cpp
index 3ef0ce765..59d2f954e 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -565,7 +565,7 @@ void Material::collision_stopping_power(double* s_col, bool positron)
 void Material::init_bremsstrahlung()
 {
   // Create new object
-  ttb_ = std::make_unique<Bremsstrahlung>();
+  ttb_ = make_unique<Bremsstrahlung>();
 
   // Get the size of the energy grids
   auto n_k = data::ttb_k_grid.size();
@@ -1245,7 +1245,7 @@ void read_materials_xml()
   // Loop over XML material elements and populate the array.
   pugi::xml_node root = doc.document_element();
   for (pugi::xml_node material_node : root.children("material")) {
-    model::materials.push_back(std::make_unique<Material>(material_node));
+    model::materials.push_back(make_unique<Material>(material_node));
   }
   model::materials.shrink_to_fit();
 }
@@ -1475,7 +1475,7 @@ openmc_extend_materials(int32_t n, int32_t* index_start, int32_t* index_end)
   if (index_start) *index_start = model::materials.size();
   if (index_end) *index_end = model::materials.size() + n - 1;
   for (int32_t i = 0; i < n; i++) {
-    model::materials.push_back(std::make_unique<Material>());
+    model::materials.push_back(make_unique<Material>());
   }
   return 0;
 }
diff --git a/src/mesh.cpp b/src/mesh.cpp
index 94248027a..11c7767eb 100644
--- a/src/mesh.cpp
+++ b/src/mesh.cpp
@@ -1366,9 +1366,9 @@ openmc_extend_meshes(int32_t n, const char* type, int32_t* index_start,
 
   for (int i = 0; i < n; ++i) {
     if (std::strcmp(type, "regular") == 0) {
-      model::meshes.push_back(std::make_unique<RegularMesh>());
+      model::meshes.push_back(make_unique<RegularMesh>());
     } else if (std::strcmp(type, "rectilinear") == 0) {
-      model::meshes.push_back(std::make_unique<RectilinearMesh>());
+      model::meshes.push_back(make_unique<RectilinearMesh>());
     } else {
       throw std::runtime_error{"Unknown mesh type: " + std::string(type)};
     }
@@ -1389,14 +1389,14 @@ extern "C" int openmc_add_unstructured_mesh(const char filename[],
 
 #ifdef DAGMC
   if (lib_name == "moab") {
-    model::meshes.push_back(std::move(std::make_unique<MOABMesh>(mesh_file)));
+    model::meshes.push_back(std::move(make_unique<MOABMesh>(mesh_file)));
     valid_lib = true;
   }
 #endif
 
 #ifdef LIBMESH
   if (lib_name == "libmesh") {
-    model::meshes.push_back(std::move(std::make_unique<LibMesh>(mesh_file)));
+    model::meshes.push_back(std::move(make_unique<LibMesh>(mesh_file)));
     valid_lib = true;
   }
 #endif
@@ -1583,7 +1583,7 @@ MOABMesh::MOABMesh(const std::string& filename) {
 
 void MOABMesh::initialize() {
   // create MOAB instance
-  mbi_ = std::make_unique<moab::Core>();
+  mbi_ = make_unique<moab::Core>();
   // load unstructured mesh file
   moab::ErrorCode rval = mbi_->load_file(filename_.c_str());
   if (rval != moab::MB_SUCCESS) {
@@ -1643,7 +1643,7 @@ MOABMesh::build_kdtree(const moab::Range& all_tets)
   all_tets_and_tris.merge(all_tris);
 
   // create a kd-tree instance
-  kdtree_ = std::make_unique<moab::AdaptiveKDTree>(mbi_.get());
+  kdtree_ = make_unique<moab::AdaptiveKDTree>(mbi_.get());
 
   // build the tree
   rval = kdtree_->build_tree(all_tets_and_tris, &kdtree_root_);
@@ -1813,10 +1813,8 @@ double MOABMesh::tet_volume(moab::EntityHandle tet) const
   return 1.0 / 6.0 * (((p[1] - p[0]) * (p[2] - p[0])) % (p[3] - p[0]));
 }
 
-void MOABMesh::surface_bins_crossed(Position r0,
-                                    Position r1,
-                                    const Direction& u,
-                                    std::vector<int>& bins) const
+void MOABMesh::surface_bins_crossed(
+  Position r0, Position r1, const Direction& u, vector<int>& bins) const
 {
 
   // TODO: Implement triangle crossings here
@@ -2148,7 +2146,7 @@ void LibMesh::initialize()
   // assuming that unstructured meshes used in OpenMC are 3D
   n_dimension_ = 3;
 
-  m_ = std::make_unique<libMesh::Mesh>(*settings::libmesh_comm, n_dimension_);
+  m_ = make_unique<libMesh::Mesh>(*settings::libmesh_comm, n_dimension_);
   m_->read(filename_);
   m_->prepare_for_use();
 
@@ -2160,7 +2158,7 @@ void LibMesh::initialize()
   // create an equation system for storing values
   eq_system_name_ = fmt::format("mesh_{}_system", id_);
 
-  equation_systems_ = std::make_unique<libMesh::EquationSystems>(*m_);
+  equation_systems_ = make_unique<libMesh::EquationSystems>(*m_);
   libMesh::ExplicitSystem& eq_sys =
     equation_systems_->add_system<libMesh::ExplicitSystem>(eq_system_name_);
 
@@ -2200,11 +2198,8 @@ int LibMesh::n_bins() const
   return m_->n_elem();
 }
 
-void
-LibMesh::surface_bins_crossed(Position r0,
-                              Position r1,
-                              const Direction& u,
-                              std::vector<int>& bins) const
+void LibMesh::surface_bins_crossed(
+  Position r0, Position r1, const Direction& u, vector<int>& bins) const
 {
   // TODO: Implement triangle crossings here
   throw std::runtime_error{"Unstructured mesh surface tallies are not implemented."};
@@ -2378,16 +2373,16 @@ void read_meshes(pugi::xml_node root)
 
     // Read mesh and add to vector
     if (mesh_type == "regular") {
-      model::meshes.push_back(std::make_unique<RegularMesh>(node));
+      model::meshes.push_back(make_unique<RegularMesh>(node));
     } else if (mesh_type == "rectilinear") {
-      model::meshes.push_back(std::make_unique<RectilinearMesh>(node));
+      model::meshes.push_back(make_unique<RectilinearMesh>(node));
 #ifdef DAGMC
     } else if (mesh_type == "unstructured" && mesh_lib == "moab") {
-      model::meshes.push_back(std::make_unique<MOABMesh>(node));
+      model::meshes.push_back(make_unique<MOABMesh>(node));
 #endif
 #ifdef LIBMESH
     } else if (mesh_type == "unstructured" && mesh_lib == "libmesh") {
-      model::meshes.push_back(std::make_unique<LibMesh>(node));
+      model::meshes.push_back(make_unique<LibMesh>(node));
 #endif
     } else if (mesh_type == "unstructured") {
       fatal_error("Unstructured mesh support is not enabled or the mesh library is invalid.");
diff --git a/src/nuclide.cpp b/src/nuclide.cpp
index 4e5c0f3bf..19c3c8113 100644
--- a/src/nuclide.cpp
+++ b/src/nuclide.cpp
@@ -200,7 +200,7 @@ Nuclide::Nuclide(hid_t group, const vector<double>& temperature)
   for (auto name : group_names(rxs_group)) {
     if (starts_with(name, "reaction_")) {
       hid_t rx_group = open_group(rxs_group, name.c_str());
-      reactions_.push_back(std::make_unique<Reaction>(rx_group, temps_to_read));
+      reactions_.push_back(make_unique<Reaction>(rx_group, temps_to_read));
 
       // Check for 0K elastic scattering
       const auto& rx = reactions_.back();
@@ -1047,7 +1047,7 @@ extern "C" int openmc_load_nuclide(const char* name, const double* temps, int n)
     // Read nuclide data from HDF5
     hid_t group = open_group(file_id, name);
     vector<double> temperature {temps, temps + n};
-    data::nuclides.push_back(std::make_unique<Nuclide>(group, temperature));
+    data::nuclides.push_back(make_unique<Nuclide>(group, temperature));
 
     close_group(group);
     file_close(file_id);
@@ -1079,7 +1079,7 @@ extern "C" int openmc_load_nuclide(const char* name, const double* temps, int n)
 
         // Read element data from HDF5
         hid_t group = open_group(file_id, element.c_str());
-        data::elements.push_back(std::make_unique<PhotonInteraction>(group));
+        data::elements.push_back(make_unique<PhotonInteraction>(group));
 
         close_group(group);
         file_close(file_id);
diff --git a/src/reaction_product.cpp b/src/reaction_product.cpp
index b3c137fe7..f73f63335 100644
--- a/src/reaction_product.cpp
+++ b/src/reaction_product.cpp
@@ -69,13 +69,13 @@ ReactionProduct::ReactionProduct(hid_t group)
     // Determine distribution type and read data
     read_attribute(dgroup, "type", temp);
     if (temp == "uncorrelated") {
-      distribution_.push_back(std::make_unique<UncorrelatedAngleEnergy>(dgroup));
+      distribution_.push_back(make_unique<UncorrelatedAngleEnergy>(dgroup));
     } else if (temp == "correlated") {
-      distribution_.push_back(std::make_unique<CorrelatedAngleEnergy>(dgroup));
+      distribution_.push_back(make_unique<CorrelatedAngleEnergy>(dgroup));
     } else if (temp == "nbody") {
-      distribution_.push_back(std::make_unique<NBodyPhaseSpace>(dgroup));
+      distribution_.push_back(make_unique<NBodyPhaseSpace>(dgroup));
     } else if (temp == "kalbach-mann") {
-      distribution_.push_back(std::make_unique<KalbachMann>(dgroup));
+      distribution_.push_back(make_unique<KalbachMann>(dgroup));
     }
 
     close_group(dgroup);
diff --git a/src/settings.cpp b/src/settings.cpp
index 426f512f1..2617da978 100644
--- a/src/settings.cpp
+++ b/src/settings.cpp
@@ -425,7 +425,7 @@ void read_settings_xml()
   for (pugi::xml_node node : root.children("source")) {
     if (check_for_node(node, "file")) {
       auto path = get_node_value(node, "file", false, true);
-      model::external_sources.push_back(std::make_unique<FileSource>(path));
+      model::external_sources.push_back(make_unique<FileSource>(path));
     } else if (check_for_node(node, "library")) {
       // Get shared library path and parameters
       auto path = get_node_value(node, "library", false, true);
@@ -435,9 +435,10 @@ void read_settings_xml()
       }
 
       // Create custom source
-      model::external_sources.push_back(std::make_unique<CustomSourceWrapper>(path, parameters));
+      model::external_sources.push_back(
+        make_unique<CustomSourceWrapper>(path, parameters));
     } else {
-      model::external_sources.push_back(std::make_unique<IndependentSource>(node));
+      model::external_sources.push_back(make_unique<IndependentSource>(node));
     }
   }
 
@@ -452,16 +453,14 @@ void read_settings_xml()
     if (check_for_node(node_ssr, "path")) {
       path = get_node_value(node_ssr, "path", false, true);
     }
-    model::external_sources.push_back(std::make_unique<FileSource>(path));
+    model::external_sources.push_back(make_unique<FileSource>(path));
   }
 
   // If no source specified, default to isotropic point source at origin with Watt spectrum
   if (model::external_sources.empty()) {
-    model::external_sources.push_back(std::make_unique<IndependentSource>(
-      UPtrSpace{new SpatialPoint({0.0, 0.0, 0.0})},
-      UPtrAngle{new Isotropic()},
-      UPtrDist{new Watt(0.988e6, 2.249e-6)}
-    ));
+    model::external_sources.push_back(make_unique<IndependentSource>(
+      UPtrSpace {new SpatialPoint({0.0, 0.0, 0.0})},
+      UPtrAngle {new Isotropic()}, UPtrDist {new Watt(0.988e6, 2.249e-6)}));
   }
 
   // Check if we want to write out source
diff --git a/src/surface.cpp b/src/surface.cpp
index 0c0303f97..76542fcd8 100644
--- a/src/surface.cpp
+++ b/src/surface.cpp
@@ -1054,40 +1054,40 @@ void read_surfaces(pugi::xml_node node)
       // Allocate and initialize the new surface
 
       if (surf_type == "x-plane") {
-        model::surfaces.push_back(std::make_unique<SurfaceXPlane>(surf_node));
+        model::surfaces.push_back(make_unique<SurfaceXPlane>(surf_node));
 
       } else if (surf_type == "y-plane") {
-        model::surfaces.push_back(std::make_unique<SurfaceYPlane>(surf_node));
+        model::surfaces.push_back(make_unique<SurfaceYPlane>(surf_node));
 
       } else if (surf_type == "z-plane") {
-        model::surfaces.push_back(std::make_unique<SurfaceZPlane>(surf_node));
+        model::surfaces.push_back(make_unique<SurfaceZPlane>(surf_node));
 
       } else if (surf_type == "plane") {
-        model::surfaces.push_back(std::make_unique<SurfacePlane>(surf_node));
+        model::surfaces.push_back(make_unique<SurfacePlane>(surf_node));
 
       } else if (surf_type == "x-cylinder") {
-        model::surfaces.push_back(std::make_unique<SurfaceXCylinder>(surf_node));
+        model::surfaces.push_back(make_unique<SurfaceXCylinder>(surf_node));
 
       } else if (surf_type == "y-cylinder") {
-        model::surfaces.push_back(std::make_unique<SurfaceYCylinder>(surf_node));
+        model::surfaces.push_back(make_unique<SurfaceYCylinder>(surf_node));
 
       } else if (surf_type == "z-cylinder") {
-        model::surfaces.push_back(std::make_unique<SurfaceZCylinder>(surf_node));
+        model::surfaces.push_back(make_unique<SurfaceZCylinder>(surf_node));
 
       } else if (surf_type == "sphere") {
-        model::surfaces.push_back(std::make_unique<SurfaceSphere>(surf_node));
+        model::surfaces.push_back(make_unique<SurfaceSphere>(surf_node));
 
       } else if (surf_type == "x-cone") {
-        model::surfaces.push_back(std::make_unique<SurfaceXCone>(surf_node));
+        model::surfaces.push_back(make_unique<SurfaceXCone>(surf_node));
 
       } else if (surf_type == "y-cone") {
-        model::surfaces.push_back(std::make_unique<SurfaceYCone>(surf_node));
+        model::surfaces.push_back(make_unique<SurfaceYCone>(surf_node));
 
       } else if (surf_type == "z-cone") {
-        model::surfaces.push_back(std::make_unique<SurfaceZCone>(surf_node));
+        model::surfaces.push_back(make_unique<SurfaceZCone>(surf_node));
 
       } else if (surf_type == "quadric") {
-        model::surfaces.push_back(std::make_unique<SurfaceQuadric>(surf_node));
+        model::surfaces.push_back(make_unique<SurfaceQuadric>(surf_node));
 
       } else {
         fatal_error(fmt::format("Invalid surface type, \"{}\"", surf_type));
diff --git a/src/tallies/filter.cpp b/src/tallies/filter.cpp
index c6dc1342f..55916401f 100644
--- a/src/tallies/filter.cpp
+++ b/src/tallies/filter.cpp
@@ -75,7 +75,7 @@ T* Filter::create(int32_t id) {
   static_assert(std::is_base_of<Filter, T>::value,
                 "Type specified is not derived from openmc::Filter");
   // Create filter and add to filters vector
-  auto filter = std::make_unique<T>();
+  auto filter = make_unique<T>();
   auto ptr_out = filter.get();
   model::tally_filters.emplace_back(std::move(filter));
   // Assign ID
diff --git a/src/tallies/tally.cpp b/src/tallies/tally.cpp
index e488d69b9..4c776528a 100644
--- a/src/tallies/tally.cpp
+++ b/src/tallies/tally.cpp
@@ -308,7 +308,7 @@ Tally::~Tally()
 Tally*
 Tally::create(int32_t id)
 {
-  model::tallies.push_back(std::make_unique<Tally>(id));
+  model::tallies.push_back(make_unique<Tally>(id));
   return model::tallies.back().get();
 }
 
@@ -737,7 +737,7 @@ void read_tallies_xml()
   }
 
   for (auto node_tal : root.children("tally")) {
-    model::tallies.push_back(std::make_unique<Tally>(node_tal));
+    model::tallies.push_back(make_unique<Tally>(node_tal));
   }
 }
 
@@ -916,7 +916,7 @@ openmc_extend_tallies(int32_t n, int32_t* index_start, int32_t* index_end)
   if (index_start) *index_start = model::tallies.size();
   if (index_end) *index_end = model::tallies.size() + n - 1;
   for (int i = 0; i < n; ++i) {
-    model::tallies.push_back(std::make_unique<Tally>(-1));
+    model::tallies.push_back(make_unique<Tally>(-1));
   }
   return 0;
 }
diff --git a/src/thermal.cpp b/src/thermal.cpp
index 4d67123a3..5e3c6d6bb 100644
--- a/src/thermal.cpp
+++ b/src/thermal.cpp
@@ -204,15 +204,14 @@ ThermalData::ThermalData(hid_t group)
     read_attribute(dgroup, "type", temp);
     if (temp == "coherent_elastic") {
       auto xs = dynamic_cast<CoherentElasticXS*>(elastic_.xs.get());
-      elastic_.distribution = std::make_unique<CoherentElasticAE>(*xs);
+      elastic_.distribution = make_unique<CoherentElasticAE>(*xs);
     } else {
       if (temp == "incoherent_elastic") {
-        elastic_.distribution = std::make_unique<IncoherentElasticAE>(dgroup);
+        elastic_.distribution = make_unique<IncoherentElasticAE>(dgroup);
       } else if (temp == "incoherent_elastic_discrete") {
         auto xs = dynamic_cast<Tabulated1D*>(elastic_.xs.get());
-        elastic_.distribution = std::make_unique<IncoherentElasticAEDiscrete>(
-          dgroup, xs->x()
-        );
+        elastic_.distribution =
+          make_unique<IncoherentElasticAEDiscrete>(dgroup, xs->x());
       }
     }
 
@@ -232,12 +231,11 @@ ThermalData::ThermalData(hid_t group)
     std::string temp;
     read_attribute(dgroup, "type", temp);
     if (temp == "incoherent_inelastic") {
-      inelastic_.distribution = std::make_unique<IncoherentInelasticAE>(dgroup);
+      inelastic_.distribution = make_unique<IncoherentInelasticAE>(dgroup);
     } else if (temp == "incoherent_inelastic_discrete") {
       auto xs = dynamic_cast<Tabulated1D*>(inelastic_.xs.get());
-      inelastic_.distribution = std::make_unique<IncoherentInelasticAEDiscrete>(
-        dgroup, xs->x()
-      );
+      inelastic_.distribution =
+        make_unique<IncoherentInelasticAEDiscrete>(dgroup, xs->x());
     }
 
     close_group(inelastic_group);
diff --git a/src/volume_calc.cpp b/src/volume_calc.cpp
index 0b37781c3..33c788358 100644
--- a/src/volume_calc.cpp
+++ b/src/volume_calc.cpp
@@ -242,7 +242,7 @@ vector<VolumeCalculation::Result> VolumeCalculation::execute() const
         for (int j = 1; j < mpi::n_procs; j++) {
           int q;
           MPI_Recv(&q, 1, MPI_INTEGER, j, 2*j, mpi::intracomm, MPI_STATUS_IGNORE);
-          std::vector<int> buffer(2*q);
+          vector<int> buffer(2 * q);
           MPI_Recv(buffer.data(), 2*q, MPI_INTEGER, j, 2*j + 1, mpi::intracomm, MPI_STATUS_IGNORE);
           for (int k = 0; k < q; ++k) {
             bool already_added = false;
@@ -261,7 +261,7 @@ vector<VolumeCalculation::Result> VolumeCalculation::execute() const
         }
       } else {
         int q = master_indices[i_domain].size();
-        std::vector<int> buffer(2*q);
+        vector<int> buffer(2 * q);
         for (int k = 0; k < q; ++k) {
           buffer[2*k] = master_indices[i_domain][k];
           buffer[2*k + 1] = master_hits[i_domain][k];
diff --git a/src/wmp.cpp b/src/wmp.cpp
index 235e82b17..4299b9400 100644
--- a/src/wmp.cpp
+++ b/src/wmp.cpp
@@ -252,7 +252,7 @@ void read_multipole_data(int i_nuclide)
 
   // Read nuclide data from HDF5
   hid_t group = open_group(file, nuc->name_.c_str());
-  nuc->multipole_ = std::make_unique<WindowedMultipole>(group);
+  nuc->multipole_ = make_unique<WindowedMultipole>(group);
   close_group(group);
   file_close(file);
 }