diff --git a/source/CMakeLists.txt b/source/CMakeLists.txt
index 18f3c45..edd2aa9 100644
--- a/source/CMakeLists.txt
+++ b/source/CMakeLists.txt
@@ -261,16 +261,20 @@ IF (STAR_COMPILER_GNU)
   SET (CMAKE_CXX_FLAGS_RELEASE "-DNDEBUG -Ofast")
 
 ELSEIF (STAR_COMPILER_CLANG)
-  SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-export_dynamic -Wall -Wextra -Wuninitialized -Wno-parentheses-equality -Wno-deprecated-declarations")
-  SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wl,-export_dynamic -Wall -Wextra -Wuninitialized -Wno-parentheses-equality -Wno-deprecated-declarations")
+  SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wuninitialized -Wno-parentheses-equality -Wno-deprecated-declarations")
+  SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wall -Wextra -Wuninitialized -Wno-parentheses-equality -Wno-deprecated-declarations")
 
   IF (STAR_SYSTEM_MACOS)
     SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
+    SET (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-export_dynamic")
+    SET (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-export_dynamic")
     SET (CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++17")
     SET (CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
   ELSEIF ()
     SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthread -D_REENTRANT")
     SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -D_REENTRANT")
+    SET (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--export_dynamic")
+    SET (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--export_dynamic")
   ENDIF ()
 
   SET (CMAKE_C_FLAGS_DEBUG "-g")
diff --git a/source/application/StarApplication.cpp b/source/application/StarApplication.cpp
index e894673..319b669 100644
--- a/source/application/StarApplication.cpp
+++ b/source/application/StarApplication.cpp
@@ -7,11 +7,11 @@ namespace Star {
 void Application::startup(StringList const&) {}
 
 void Application::applicationInit(ApplicationControllerPtr appController) {
-  m_appController = move(appController);
+  m_appController = std::move(appController);
 }
 
 void Application::renderInit(RendererPtr renderer) {
-  m_renderer = move(renderer);
+  m_renderer = std::move(renderer);
 }
 
 void Application::windowChanged(WindowMode, Vec2U) {}
diff --git a/source/application/StarMainApplication_sdl.cpp b/source/application/StarMainApplication_sdl.cpp
index 48b7fa5..08d3813 100644
--- a/source/application/StarMainApplication_sdl.cpp
+++ b/source/application/StarMainApplication_sdl.cpp
@@ -206,7 +206,7 @@ ControllerButton controllerButtonFromSdlControllerButton(uint8_t button) {
 class SdlPlatform {
 public:
   SdlPlatform(ApplicationUPtr application, StringList cmdLineArgs) {
-    m_application = move(application);
+    m_application = std::move(application);
 
     // extract application path from command line args
     String applicationPath = cmdLineArgs.first();
@@ -215,7 +215,7 @@ public:
     StringList platformArguments;
     eraseWhere(cmdLineArgs, [&platformArguments](String& argument) {
         if (argument.beginsWith("+platform")) {
-          platformArguments.append(move(argument));
+          platformArguments.append(std::move(argument));
           return true;
         }
         return false;
@@ -461,7 +461,7 @@ private:
       Maybe<String> string;
       if (SDL_HasClipboardText()) {
         if (auto text = SDL_GetClipboardText()) {
-          if (*text != NULL)
+          if (*text != '\0')
             string.emplace(text);
           SDL_free(text);
         }
@@ -482,7 +482,7 @@ private:
     }
 
     void setApplicationTitle(String title) override {
-      parent->m_windowTitle = move(title);
+      parent->m_windowTitle = std::move(title);
       if (parent->m_sdlWindow)
         SDL_SetWindowTitle(parent->m_sdlWindow, parent->m_windowTitle.utf8Ptr());
     }
@@ -817,10 +817,10 @@ private:
       else
         operations = { FlipImageOperation{ FlipImageOperation::Mode::FlipY } };
 
-      auto newImage = std::make_shared<Image>(move(processImageOperations(operations, *image)));
+      auto newImage = std::make_shared<Image>(processImageOperations(operations, *image));
       // Fix fully transparent pixels inverting the underlying display pixel on Windows (allowing this could be made configurable per cursor later!)
       newImage->forEachPixel([](unsigned x, unsigned y, Vec4B& pixel) { if (!pixel[3]) pixel[0] = pixel[1] = pixel[2] = 0; });
-      entry->image = move(newImage);
+      entry->image = std::move(newImage);
       
 
       auto size = entry->image->size();
@@ -907,7 +907,7 @@ private:
 int runMainApplication(ApplicationUPtr application, StringList cmdLineArgs) {
   try {
     {
-      SdlPlatform platform(move(application), move(cmdLineArgs));
+      SdlPlatform platform(std::move(application), std::move(cmdLineArgs));
       platform.run();
     }
     Logger::info("Application: stopped gracefully");
diff --git a/source/application/StarP2PNetworkingService_pc.cpp b/source/application/StarP2PNetworkingService_pc.cpp
index 0170eb0..f13bb62 100644
--- a/source/application/StarP2PNetworkingService_pc.cpp
+++ b/source/application/StarP2PNetworkingService_pc.cpp
@@ -19,9 +19,9 @@ PcP2PNetworkingService::PcP2PNetworkingService(PcPlatformServicesStatePtr state)
   : m_callbackConnectionFailure(this, &PcP2PNetworkingService::steamOnConnectionFailure),
     m_callbackJoinRequested(this, &PcP2PNetworkingService::steamOnJoinRequested),
     m_callbackSessionRequest(this, &PcP2PNetworkingService::steamOnSessionRequest),
-    m_state(move(state)) {
+    m_state(std::move(state)) {
 #else
-  : m_state(move(state)) {
+  : m_state(std::move(state)) {
 #endif
 
 #ifdef STAR_ENABLE_DISCORD_INTEGRATION
@@ -224,7 +224,7 @@ Either<String, P2PSocketUPtr> PcP2PNetworkingService::connectToPeer(P2PNetworkin
     if (type == "discord") {
       auto remoteUserId = lexicalCast<discord::UserId>(peerId.extract("_"));
       auto lobbyId = lexicalCast<discord::LobbyId>(peerId.extract("_"));
-      String lobbySecret = move(peerId);
+      String lobbySecret = std::move(peerId);
       return makeRight(discordConnectRemote(remoteUserId, lobbyId, lobbySecret));
     }
   }
@@ -242,7 +242,7 @@ void PcP2PNetworkingService::addPendingJoin(String connectionString) {
   if (connectionString.extract(":") != "connect")
     throw ApplicationException::format("malformed connection string '{}'", connectionString);
 
-  String target = move(connectionString);
+  String target = std::move(connectionString);
   String targetType = target.extract("_");
 
   if (targetType == "address")
@@ -357,7 +357,7 @@ void PcP2PNetworkingService::steamReceiveAll() {
     SteamNetworking()->ReadP2PPacket(data.ptr(), messageSize, &messageSize, &messageRemoteUser);
     if (auto openSocket = m_steamOpenSockets.value(messageRemoteUser.ConvertToUint64())) {
       MutexLocker socketLocker(openSocket->mutex);
-      openSocket->incoming.append(move(data));
+      openSocket->incoming.append(std::move(data));
     }
   }
 }
@@ -474,7 +474,7 @@ P2PSocketUPtr PcP2PNetworkingService::discordConnectRemote(discord::UserId remot
       }
     });
 
-  return unique_ptr<P2PSocket>(move(socket));
+  return unique_ptr<P2PSocket>(std::move(socket));
 }
 
 void PcP2PNetworkingService::discordOnReceiveMessage(discord::LobbyId lobbyId, discord::UserId userId, discord::NetworkChannelId channel, uint8_t* data, uint32_t size) {
@@ -507,7 +507,7 @@ void PcP2PNetworkingService::discordOnLobbyMemberConnect(discord::LobbyId lobbyI
       socket->mode = DiscordSocketMode::Connected;
 
       m_discordOpenSockets[userId] = socket.get();
-      m_pendingIncomingConnections.append(move(socket));
+      m_pendingIncomingConnections.append(std::move(socket));
       Logger::info("Accepted new discord connection from remote user {}", userId);
     }
   }
diff --git a/source/application/StarPlatformServices_pc.cpp b/source/application/StarPlatformServices_pc.cpp
index 7023129..8f940b3 100644
--- a/source/application/StarPlatformServices_pc.cpp
+++ b/source/application/StarPlatformServices_pc.cpp
@@ -118,7 +118,7 @@ PcPlatformServicesUPtr PcPlatformServices::create(String const& path, StringList
     for (auto& argument : platformArguments) {
       if (argument.beginsWith("+platform:connect:")) {
         Logger::info("PC platform services joining from command line argument '{}'", argument);
-        p2pNetworkingService->addPendingJoin(move(argument));
+        p2pNetworkingService->addPendingJoin(std::move(argument));
       } else {
         throw ApplicationException::format("Unrecognized PC platform services command line argument '{}'", argument);
       }
diff --git a/source/application/StarRenderer.cpp b/source/application/StarRenderer.cpp
index f4aa4fe..764dd4a 100644
--- a/source/application/StarRenderer.cpp
+++ b/source/application/StarRenderer.cpp
@@ -19,7 +19,7 @@ RenderQuad::RenderQuad(Vec2F posA, Vec2F posB, Vec2F posC, Vec2F posD, Vec4B col
   d = { posD, { 0, 0 }, color, param1 };
 }
 
-RenderQuad::RenderQuad(TexturePtr tex, Vec2F minPosition, float textureScale, Vec4B color, float param1) : texture(move(tex)) {
+RenderQuad::RenderQuad(TexturePtr tex, Vec2F minPosition, float textureScale, Vec4B color, float param1) : texture(std::move(tex)) {
   Vec2F size = Vec2F(texture->size());
   a = { minPosition, { 0, 0 }, color, param1};
   b = { { (minPosition[0] + size[0] * textureScale), minPosition[1] }, { size[0], 0 }, color, param1 };
@@ -27,7 +27,7 @@ RenderQuad::RenderQuad(TexturePtr tex, Vec2F minPosition, float textureScale, Ve
   d = { { minPosition[0], (minPosition[1] + size[1] * textureScale) }, { 0, size[1] }, color, param1 };
 }
 
-RenderQuad::RenderQuad(TexturePtr tex, RectF const& screenCoords, Vec4B color, float param1) : texture(move(tex)) {
+RenderQuad::RenderQuad(TexturePtr tex, RectF const& screenCoords, Vec4B color, float param1) : texture(std::move(tex)) {
   Vec2F size = Vec2F(texture->size());
   a = { screenCoords.min(), { 0, 0 }, color, param1 };
   b = { { screenCoords.xMax(), screenCoords.yMin(), }, { size[0], 0.f }, color, param1 };
@@ -35,7 +35,7 @@ RenderQuad::RenderQuad(TexturePtr tex, RectF const& screenCoords, Vec4B color, f
   d = { { screenCoords.xMin(), screenCoords.yMax(), }, { 0.f, size[1] }, color, param1 };
 }
 
-RenderQuad::RenderQuad(TexturePtr tex, Vec2F posA, Vec2F uvA, Vec2F posB, Vec2F uvB, Vec2F posC, Vec2F uvC, Vec2F posD, Vec2F uvD, Vec4B color, float param1) : texture(move(tex)) {
+RenderQuad::RenderQuad(TexturePtr tex, Vec2F posA, Vec2F uvA, Vec2F posB, Vec2F uvB, Vec2F posC, Vec2F uvC, Vec2F posD, Vec2F uvD, Vec4B color, float param1) : texture(std::move(tex)) {
   a = { posA, uvA, color, param1 };
   b = { posB, uvB, color, param1 };
   c = { posC, uvC, color, param1 };
@@ -43,7 +43,7 @@ RenderQuad::RenderQuad(TexturePtr tex, Vec2F posA, Vec2F uvA, Vec2F posB, Vec2F
 }
 
 RenderQuad::RenderQuad(TexturePtr tex, RenderVertex vA, RenderVertex vB, RenderVertex vC, RenderVertex vD)
-  : texture(move(tex)), a(move(vA)), b(move(vB)), c(move(vC)), d(move(vD)) {}
+  : texture(std::move(tex)), a(std::move(vA)), b(std::move(vB)), c(std::move(vC)), d(std::move(vD)) {}
 
 RenderQuad::RenderQuad(RectF const& rect, Vec4B color, float param1)
   : a{ rect.min(), {}, color, param1 }
@@ -64,18 +64,18 @@ RenderTriangle::RenderTriangle(Vec2F posA, Vec2F posB, Vec2F posC, Vec4B color,
   c = { posC, { 0, 0 }, color, param1 };
 }
 
-RenderTriangle::RenderTriangle(TexturePtr tex, Vec2F posA, Vec2F uvA, Vec2F posB, Vec2F uvB, Vec2F posC, Vec2F uvC, Vec4B color, float param1) : texture(move(tex)) {
+RenderTriangle::RenderTriangle(TexturePtr tex, Vec2F posA, Vec2F uvA, Vec2F posB, Vec2F uvB, Vec2F posC, Vec2F uvC, Vec4B color, float param1) : texture(std::move(tex)) {
   a = { posA, uvA, color, param1 };
   b = { posB, uvB, color, param1 };
   c = { posC, uvC, color, param1 };
 }
 
 RenderQuad renderTexturedRect(TexturePtr texture, Vec2F minPosition, float textureScale, Vec4B color, float param1) {
-  return RenderQuad(move(texture), minPosition, textureScale, color, param1);
+  return RenderQuad(std::move(texture), minPosition, textureScale, color, param1);
 }
 
 RenderQuad renderTexturedRect(TexturePtr texture, RectF const& screenCoords, Vec4B color, float param1) {
-  return RenderQuad(move(texture), screenCoords, color, param1);
+  return RenderQuad(std::move(texture), screenCoords, color, param1);
 }
 
 RenderQuad renderFlatRect(RectF const& rect, Vec4B color, float param1) {
diff --git a/source/application/StarRenderer_opengl20.cpp b/source/application/StarRenderer_opengl20.cpp
index f85f0e8..18f771b 100644
--- a/source/application/StarRenderer_opengl20.cpp
+++ b/source/application/StarRenderer_opengl20.cpp
@@ -416,7 +416,7 @@ List<RenderPrimitive>& OpenGl20Renderer::immediatePrimitives() {
 }
 
 void OpenGl20Renderer::render(RenderPrimitive primitive) {
-  m_immediatePrimitives.append(move(primitive));
+  m_immediatePrimitives.append(std::move(primitive));
 }
 
 void OpenGl20Renderer::renderBuffer(RenderBufferPtr const& renderBuffer, Mat3F const& transformation) {
@@ -672,7 +672,7 @@ void OpenGl20Renderer::GlRenderBuffer::set(List<RenderPrimitive>& primitives) {
         glBufferData(GL_ARRAY_BUFFER, accumulationBuffer.size(), accumulationBuffer.ptr(), GL_STREAM_DRAW);
       }
 
-      vertexBuffers.emplace_back(move(vb));
+      vertexBuffers.emplace_back(std::move(vb));
 
       currentTextures.clear();
       currentTextureSizes.clear();
@@ -701,7 +701,7 @@ void OpenGl20Renderer::GlRenderBuffer::set(List<RenderPrimitive>& primitives) {
 
     if (auto gt = as<GlGroupedTexture>(texture.get()))
       gt->incrementBufferUseCount();
-    usedTextures.add(move(texture));
+    usedTextures.add(std::move(texture));
 
     return {float(textureIndex), Vec2F(glTexture->glTextureCoordinateOffset())};
   };
@@ -723,14 +723,14 @@ void OpenGl20Renderer::GlRenderBuffer::set(List<RenderPrimitive>& primitives) {
   Texture* lastTexture = nullptr;
   for (auto& primitive : primitives) {
     if (auto tri = primitive.ptr<RenderTriangle>()) {
-      tie(textureIndex, textureOffset) = addCurrentTexture(move(tri->texture));
+      tie(textureIndex, textureOffset) = addCurrentTexture(std::move(tri->texture));
 
       appendBufferVertex(tri->a, textureIndex, textureOffset);
       appendBufferVertex(tri->b, textureIndex, textureOffset);
       appendBufferVertex(tri->c, textureIndex, textureOffset);
 
     } else if (auto quad = primitive.ptr<RenderQuad>()) {
-      tie(textureIndex, textureOffset) = addCurrentTexture(move(quad->texture));
+      tie(textureIndex, textureOffset) = addCurrentTexture(std::move(quad->texture));
 
       appendBufferVertex(quad->a, textureIndex, textureOffset);
       appendBufferVertex(quad->b, textureIndex, textureOffset);
@@ -742,7 +742,7 @@ void OpenGl20Renderer::GlRenderBuffer::set(List<RenderPrimitive>& primitives) {
 
     } else if (auto poly = primitive.ptr<RenderPoly>()) {
       if (poly->vertexes.size() > 2) {
-        tie(textureIndex, textureOffset) = addCurrentTexture(move(poly->texture));
+        tie(textureIndex, textureOffset) = addCurrentTexture(std::move(poly->texture));
 
         for (size_t i = 1; i < poly->vertexes.size() - 1; ++i) {
           appendBufferVertex(poly->vertexes[0], textureIndex, textureOffset);
diff --git a/source/application/StarTextureAtlas.hpp b/source/application/StarTextureAtlas.hpp
index db5a163..595f6ba 100644
--- a/source/application/StarTextureAtlas.hpp
+++ b/source/application/StarTextureAtlas.hpp
@@ -33,6 +33,8 @@ public:
 
   TextureAtlasSet(unsigned cellSize, unsigned atlasNumCells);
 
+  virtual ~TextureAtlasSet() = default;
+
   // The constant square size of all atlas textures
   Vec2U atlasTextureSize() const;
 
@@ -88,6 +90,8 @@ private:
   };
 
   struct TextureEntry : Texture {
+    virtual ~TextureEntry() = default;
+
     Vec2U imageSize() const override;
 
     AtlasTextureHandle const& atlasTexture() const override;
@@ -168,7 +172,7 @@ auto TextureAtlasSet<AtlasTextureHandle>::addTexture(Image const& image, bool bo
       return nullptr;
 
     auto textureEntry = make_shared<TextureEntry>();
-    textureEntry->textureImage = move(finalImage);
+    textureEntry->textureImage = std::move(finalImage);
     textureEntry->atlasPlacement = *placement;
 
     m_textures.add(textureEntry);
diff --git a/source/base/StarAnimatedPartSet.cpp b/source/base/StarAnimatedPartSet.cpp
index 3f5d72a..9133921 100644
--- a/source/base/StarAnimatedPartSet.cpp
+++ b/source/base/StarAnimatedPartSet.cpp
@@ -27,7 +27,7 @@ AnimatedPartSet::AnimatedPartSet(Json config) {
       newState->transitionState = stateConfig.getString("transition", "");
       newState->stateProperties = stateConfig.getObject("properties", {});
       newState->stateFrameProperties = stateConfig.getObject("frameProperties", {});
-      newStateType.states[stateName] = move(newState);
+      newStateType.states[stateName] = std::move(newState);
     }
 
     newStateType.states.sortByKey();
@@ -38,7 +38,7 @@ AnimatedPartSet::AnimatedPartSet(Json config) {
     if (newStateType.defaultState.empty() && !newStateType.states.empty())
       newStateType.defaultState = newStateType.states.firstKey();
 
-    m_stateTypes[stateTypeName] = move(newStateType);
+    m_stateTypes[stateTypeName] = std::move(newStateType);
   }
 
   // Sort state types by decreasing priority.
@@ -61,13 +61,13 @@ AnimatedPartSet::AnimatedPartSet(Json config) {
         auto const& stateConfig = partStatePair.second;
 
         PartState partState = {stateConfig.getObject("properties", {}), stateConfig.getObject("frameProperties", {})};
-        newPart.partStates[stateTypeName][stateName] = move(partState);
+        newPart.partStates[stateTypeName][stateName] = std::move(partState);
       }
     }
     newPart.activePart.partName = partPair.first;
     newPart.activePartDirty = true;
 
-    m_parts[partName] = move(newPart);
+    m_parts[partName] = std::move(newPart);
   }
 
   for (auto const& pair : m_stateTypes)
diff --git a/source/base/StarAssets.cpp b/source/base/StarAssets.cpp
index 8956ba9..135945c 100644
--- a/source/base/StarAssets.cpp
+++ b/source/base/StarAssets.cpp
@@ -71,17 +71,17 @@ Maybe<RectU> FramesSpecification::getRect(String const& frame) const {
 Assets::Assets(Settings settings, StringList assetSources) {
   const char* const AssetsPatchSuffix = ".patch";
 
-  m_settings = move(settings);
+  m_settings = std::move(settings);
   m_stopThreads = false;
-  m_assetSources = move(assetSources);
+  m_assetSources = std::move(assetSources);
 
   for (auto& sourcePath : m_assetSources) {
     Logger::info("Loading assets from: '{}'", sourcePath);
     AssetSourcePtr source;
     if (File::isDirectory(sourcePath))
-      source = make_shared<DirectoryAssetSource>(sourcePath, m_settings.pathIgnore);
+      source = std::make_shared<DirectoryAssetSource>(sourcePath, m_settings.pathIgnore);
     else
-      source = make_shared<PackedAssetSource>(sourcePath);
+      source = std::make_shared<PackedAssetSource>(sourcePath);
 
     m_assetSourcePaths.add(sourcePath, source);
 
@@ -225,7 +225,7 @@ Json Assets::json(String const& path) const {
   auto components = AssetPath::split(path);
   validatePath(components, true, false);
 
-  return as<JsonData>(getAsset(AssetId{AssetType::Json, move(components)}))->json;
+  return as<JsonData>(getAsset(AssetId{AssetType::Json, std::move(components)}))->json;
 }
 
 Json Assets::fetchJson(Json const& v, String const& dir) const {
@@ -255,7 +255,7 @@ void Assets::queueImages(StringList const& paths) const {
     auto components = AssetPath::split(path);
     validatePath(components, true, true);
 
-    return AssetId{AssetType::Image, move(components)};
+    return AssetId{AssetType::Image, std::move(components)};
   }));
 }
 
@@ -280,7 +280,7 @@ AudioConstPtr Assets::audio(String const& path) const {
   auto components = AssetPath::split(path);
   validatePath(components, false, false);
 
-  return as<AudioData>(getAsset(AssetId{AssetType::Audio, move(components)}))->audio;
+  return as<AudioData>(getAsset(AssetId{AssetType::Audio, std::move(components)}))->audio;
 }
 
 void Assets::queueAudios(StringList const& paths) const {
@@ -288,7 +288,7 @@ void Assets::queueAudios(StringList const& paths) const {
     const auto components = AssetPath::split(path);
     validatePath(components, false, false);
 
-    return AssetId{AssetType::Audio, move(components)};
+    return AssetId{AssetType::Audio, std::move(components)};
   }));
 }
 
@@ -296,7 +296,7 @@ AudioConstPtr Assets::tryAudio(String const& path) const {
   auto components = AssetPath::split(path);
   validatePath(components, false, false);
 
-  if (auto audioData = as<AudioData>(tryAsset(AssetId{AssetType::Audio, move(components)})))
+  if (auto audioData = as<AudioData>(tryAsset(AssetId{AssetType::Audio, std::move(components)})))
     return audioData->audio;
   else
     return {};
@@ -306,14 +306,14 @@ FontConstPtr Assets::font(String const& path) const {
   auto components = AssetPath::split(path);
   validatePath(components, false, false);
 
-  return as<FontData>(getAsset(AssetId{AssetType::Font, move(components)}))->font;
+  return as<FontData>(getAsset(AssetId{AssetType::Font, std::move(components)}))->font;
 }
 
 ByteArrayConstPtr Assets::bytes(String const& path) const {
   auto components = AssetPath::split(path);
   validatePath(components, false, false);
 
-  return as<BytesData>(getAsset(AssetId{AssetType::Bytes, move(components)}))->bytes;
+  return as<BytesData>(getAsset(AssetId{AssetType::Bytes, std::move(components)}))->bytes;
 }
 
 IODevicePtr Assets::openFile(String const& path) const {
@@ -386,7 +386,7 @@ bool Assets::BytesData::shouldPersist() const {
 FramesSpecification Assets::parseFramesSpecification(Json const& frameConfig, String path) {
   FramesSpecification framesSpecification;
 
-  framesSpecification.framesFile = move(path);
+  framesSpecification.framesFile = std::move(path);
 
   if (frameConfig.contains("frameList")) {
     for (auto const& pair : frameConfig.get("frameList").toObject()) {
@@ -469,7 +469,7 @@ FramesSpecification Assets::parseFramesSpecification(Json const& frameConfig, St
 
       if (!framesSpecification.frames.contains(value))
         throw AssetException(strf("No such frame '{}' found for alias '{}'", value, key));
-      framesSpecification.aliases[key] = move(value);
+      framesSpecification.aliases[key] = std::move(value);
     }
   }
 
@@ -866,7 +866,7 @@ shared_ptr<Assets::AssetData> Assets::loadImage(AssetPath const& path) const {
     for (auto const& ref : referencePaths) {
       auto components = AssetPath::split(ref);
       validatePath(components, true, false);
-      auto refImage = as<ImageData>(loadAsset(AssetId{AssetType::Image, move(components)}));
+      auto refImage = as<ImageData>(loadAsset(AssetId{AssetType::Image, std::move(components)}));
       if (!refImage)
         return {};
       references[ref] = refImage->image;
@@ -881,7 +881,7 @@ shared_ptr<Assets::AssetData> Assets::loadImage(AssetPath const& path) const {
         else
           processImageOperation(entry.operation, newImage, [&](String const& ref) { return references.get(ref).get(); });
       });
-      newData->image = make_shared<Image>(move(newImage));
+      newData->image = make_shared<Image>(std::move(newImage));
       return newData;
     });
 
diff --git a/source/base/StarDirectoryAssetSource.cpp b/source/base/StarDirectoryAssetSource.cpp
index 675c64c..f375e4a 100644
--- a/source/base/StarDirectoryAssetSource.cpp
+++ b/source/base/StarDirectoryAssetSource.cpp
@@ -62,7 +62,7 @@ void DirectoryAssetSource::setMetadata(JsonObject metadata) {
     if (!m_metadataFile)
       m_metadataFile = String("/_metadata");
 
-    m_metadata = move(metadata);
+    m_metadata = std::move(metadata);
 
     if (m_metadata.empty())
       File::remove(toFilesystem(*m_metadataFile));
@@ -88,7 +88,7 @@ void DirectoryAssetSource::scanAll(String const& assetDirectory, StringList& out
       scanAll(assetPath + "/", output);
     } else {
       if (!shouldIgnore(assetPath))
-        output.append(move(assetPath));
+        output.append(std::move(assetPath));
     }
   }
 }
diff --git a/source/base/StarMixer.cpp b/source/base/StarMixer.cpp
index d3c7c5a..be0bea8 100644
--- a/source/base/StarMixer.cpp
+++ b/source/base/StarMixer.cpp
@@ -218,7 +218,7 @@ void Mixer::setVolume(float volume, float rampTime) {
 
 void Mixer::play(AudioInstancePtr sample) {
   MutexLocker locker(m_queueMutex);
-  m_audios.add(move(sample), AudioState{List<float>(m_channels, 1.0f)});
+  m_audios.add(std::move(sample), AudioState{List<float>(m_channels, 1.0f)});
 }
 
 void Mixer::stopAll(float rampTime) {
diff --git a/source/client/StarClientApplication.cpp b/source/client/StarClientApplication.cpp
index 47e5596..d44bd6e 100644
--- a/source/client/StarClientApplication.cpp
+++ b/source/client/StarClientApplication.cpp
@@ -607,7 +607,7 @@ void ClientApplication::changeState(MainAppState newState) {
             setError(strf("Cannot join peer: {}", result.left()));
             return;
           } else {
-            packetSocket = P2PPacketSocket::open(move(result.right()));
+            packetSocket = P2PPacketSocket::open(std::move(result.right()));
           }
         } else {
           setError("Internal error, no p2p networking service when joining p2p networking peer");
@@ -616,7 +616,7 @@ void ClientApplication::changeState(MainAppState newState) {
       }
 
       bool allowAssetsMismatch = m_root->configuration()->get("allowAssetsMismatch").toBool();
-      if (auto errorMessage = m_universeClient->connect(UniverseConnection(move(packetSocket)), allowAssetsMismatch,
+      if (auto errorMessage = m_universeClient->connect(UniverseConnection(std::move(packetSocket)), allowAssetsMismatch,
             multiPlayerConnection.account, multiPlayerConnection.password)) {
         setError(*errorMessage);
         return;
@@ -951,7 +951,7 @@ void ClientApplication::updateRunning(float dt) {
     if (m_universeServer) {
       if (auto p2pNetworkingService = appController()->p2pNetworkingService()) {
         for (auto& p2pClient : p2pNetworkingService->acceptP2PConnections())
-          m_universeServer->addClient(UniverseConnection(P2PPacketSocket::open(move(p2pClient))));
+          m_universeServer->addClient(UniverseConnection(P2PPacketSocket::open(std::move(p2pClient))));
       }
 
       m_universeServer->setPause(m_mainInterface->escapeDialogOpen());
diff --git a/source/core/StarAStar.hpp b/source/core/StarAStar.hpp
index 52dc5d4..eedac8c 100644
--- a/source/core/StarAStar.hpp
+++ b/source/core/StarAStar.hpp
@@ -121,7 +121,7 @@ namespace AStar {
 
   template <class Edge, class Node>
   void Search<Edge, Node>::start(Node startNode, Node goalNode) {
-    m_goal = move(goalNode);
+    m_goal = std::move(goalNode);
     m_nodeMeta.clear();
     m_openQueue = std::priority_queue<ScoredNode>();
     m_openSet.clear();
@@ -137,7 +137,7 @@ namespace AStar {
     m_nodeMeta[startNode].score = startScore;
 
     m_openSet.insert(startNode);
-    m_openQueue.push(ScoredNode{startScore, move(startNode)});
+    m_openQueue.push(ScoredNode{startScore, std::move(startNode)});
   }
 
   template <class Edge, class Node>
@@ -251,7 +251,7 @@ namespace AStar {
 
   template <class Edge, class Node>
   Maybe<Path<Edge>> const& Search<Edge, Node>::findPath(Node startNode, Node goalNode) {
-    start(move(startNode), move(goalNode));
+    start(std::move(startNode), std::move(goalNode));
     explore();
     return result();
   }
diff --git a/source/core/StarAlgorithm.hpp b/source/core/StarAlgorithm.hpp
index e26917a..ef82cc8 100644
--- a/source/core/StarAlgorithm.hpp
+++ b/source/core/StarAlgorithm.hpp
@@ -14,7 +14,7 @@ template <typename ToType>
 struct construct {
   template <typename... FromTypes>
   ToType operator()(FromTypes&&... fromTypes) const {
-    return ToType(forward<FromTypes>(fromTypes)...);
+    return ToType(std::forward<FromTypes>(fromTypes)...);
   }
 };
 
@@ -29,7 +29,7 @@ template <typename Func>
 struct SwallowReturn {
   template <typename... T>
   void operator()(T&&... args) {
-    func(forward<T>(args)...);
+    func(std::forward<T>(args)...);
   }
 
   Func func;
@@ -37,7 +37,7 @@ struct SwallowReturn {
 
 template <typename Func>
 SwallowReturn<Func> swallow(Func f) {
-  return SwallowReturn<Func>{move(f)};
+  return SwallowReturn<Func>{std::move(f)};
 }
 
 struct Empty {
@@ -58,18 +58,18 @@ struct FunctionComposer {
 
   template <typename... T>
   decltype(auto) operator()(T&&... args) {
-    return f1(f2(forward<T>(args)...));
+    return f1(f2(std::forward<T>(args)...));
   }
 };
 
 template <typename FirstFunction, typename SecondFunction>
 decltype(auto) compose(FirstFunction&& firstFunction, SecondFunction&& secondFunction) {
-  return FunctionComposer<FirstFunction, SecondFunction>{move(forward<FirstFunction>(firstFunction)), move(forward<SecondFunction>(secondFunction))};
+  return FunctionComposer<FirstFunction, SecondFunction>{std::move(std::forward<FirstFunction>(firstFunction)), std::move(std::forward<SecondFunction>(secondFunction))};
 }
 
 template <typename FirstFunction, typename SecondFunction, typename ThirdFunction, typename... RestFunctions>
 decltype(auto) compose(FirstFunction firstFunction, SecondFunction secondFunction, ThirdFunction thirdFunction, RestFunctions... restFunctions) {
-  return compose(forward<FirstFunction>(firstFunction), compose(forward<SecondFunction>(secondFunction), compose(forward<ThirdFunction>(thirdFunction), forward<RestFunctions>(restFunctions)...)));
+  return compose(std::forward<FirstFunction>(firstFunction), compose(std::forward<SecondFunction>(secondFunction), compose(std::forward<ThirdFunction>(thirdFunction), std::forward<RestFunctions>(restFunctions)...)));
 }
 
 template <typename Container, typename Value, typename Function>
@@ -260,7 +260,7 @@ void sortByComputedValue(Container& container, Getter&& valueGetter, bool stable
 
 template <typename Container, typename Getter>
 void stableSortByComputedValue(Container& container, Getter&& valueGetter) {
-  return sortByComputedValue(container, forward<Getter>(valueGetter), true);
+  return sortByComputedValue(container, std::forward<Getter>(valueGetter), true);
 }
 
 template <typename Container>
@@ -293,7 +293,7 @@ template <typename OutContainer, typename InContainer, typename Function>
 void transformInto(OutContainer& outContainer, InContainer&& inContainer, Function&& function) {
   for (auto&& elem : inContainer) {
     if (std::is_rvalue_reference<InContainer&&>::value)
-      outContainer.insert(outContainer.end(), function(move(elem)));
+      outContainer.insert(outContainer.end(), function(std::move(elem)));
     else
       outContainer.insert(outContainer.end(), function(elem));
   }
@@ -302,7 +302,7 @@ void transformInto(OutContainer& outContainer, InContainer&& inContainer, Functi
 template <typename OutContainer, typename InContainer, typename Function>
 OutContainer transform(InContainer&& container, Function&& function) {
   OutContainer res;
-  transformInto(res, forward<InContainer>(container), forward<Function>(function));
+  transformInto(res, std::forward<InContainer>(container), std::forward<Function>(function));
   return res;
 }
 
@@ -326,7 +326,7 @@ OutputContainer zipWith(Function&& function, Container1 const& cont1, Container2
 // default constructed state.
 template <typename T>
 T take(T& t) {
-  T t2 = move(t);
+  T t2 = std::move(t);
   t = T();
   return t2;
 }
@@ -356,7 +356,7 @@ public:
 
     template <typename T>
     OutputProxy& operator=(T&& value) {
-      m_function(forward<T>(value));
+      m_function(std::forward<T>(value));
       return *this;
     }
 
@@ -365,7 +365,7 @@ public:
   };
 
   explicit FunctionOutputIterator(UnaryFunction f = UnaryFunction())
-    : m_function(move(f)) {}
+    : m_function(std::move(f)) {}
 
   OutputProxy operator*() {
     return OutputProxy(m_function);
@@ -385,7 +385,7 @@ private:
 
 template <typename UnaryFunction>
 FunctionOutputIterator<UnaryFunction> makeFunctionOutputIterator(UnaryFunction f) {
-  return FunctionOutputIterator<UnaryFunction>(move(f));
+  return FunctionOutputIterator<UnaryFunction>(std::move(f));
 }
 
 // Wraps a nullary function to produce an input iterator
@@ -401,7 +401,7 @@ public:
   typedef typename std::result_of<NullaryFunction()>::type FunctionReturnType;
 
   explicit FunctionInputIterator(NullaryFunction f = {})
-    : m_function(move(f)) {}
+    : m_function(std::move(f)) {}
 
   FunctionReturnType operator*() {
     return m_function();
@@ -421,7 +421,7 @@ private:
 
 template <typename NullaryFunction>
 FunctionInputIterator<NullaryFunction> makeFunctionInputIterator(NullaryFunction f) {
-  return FunctionInputIterator<NullaryFunction>(move(f));
+  return FunctionInputIterator<NullaryFunction>(std::move(f));
 }
 
 template <typename Iterable>
@@ -449,14 +449,14 @@ ReverseWrapper<Iterable> reverseIterate(Iterable& list) {
 template <typename Functor>
 class FinallyGuard {
 public:
-  FinallyGuard(Functor functor) : functor(move(functor)), dismiss(false) {}
+  FinallyGuard(Functor functor) : functor(std::move(functor)), dismiss(false) {}
 
-  FinallyGuard(FinallyGuard&& o) : functor(move(o.functor)), dismiss(o.dismiss) {
+  FinallyGuard(FinallyGuard&& o) : functor(std::move(o.functor)), dismiss(o.dismiss) {
     o.cancel();
   }
 
   FinallyGuard& operator=(FinallyGuard&& o) {
-    functor = move(o.functor);
+    functor = std::move(o.functor);
     dismiss = o.dismiss;
     o.cancel();
     return *this;
@@ -478,7 +478,7 @@ private:
 
 template <typename Functor>
 FinallyGuard<typename std::decay<Functor>::type> finally(Functor&& f) {
-  return FinallyGuard<Functor>(forward<Functor>(f));
+  return FinallyGuard<Functor>(std::forward<Functor>(f));
 }
 
 // Generates compile time sequences of indexes from MinIndex to MaxIndex
@@ -498,12 +498,12 @@ struct GenIndexSequence<Min, Min, S...> {
 
 template <typename Function, typename Tuple, size_t... Indexes>
 decltype(auto) tupleUnpackFunctionIndexes(Function&& function, Tuple&& args, IndexSequence<Indexes...> const&) {
-  return function(get<Indexes>(forward<Tuple>(args))...);
+  return function(get<Indexes>(std::forward<Tuple>(args))...);
 }
 
 template <typename Function, typename Tuple>
 decltype(auto) tupleUnpackFunction(Function&& function, Tuple&& args) {
-  return tupleUnpackFunctionIndexes<Function, Tuple>(forward<Function>(function), forward<Tuple>(args),
+  return tupleUnpackFunctionIndexes<Function, Tuple>(std::forward<Function>(function), std::forward<Tuple>(args),
       typename GenIndexSequence<0, std::tuple_size<typename std::decay<Tuple>::type>::value>::type());
 }
 
@@ -512,12 +512,12 @@ decltype(auto) tupleUnpackFunction(Function&& function, Tuple&& args) {
 
 template <typename Function, typename Tuple, size_t... Indexes>
 decltype(auto) tupleApplyFunctionIndexes(Function&& function, Tuple&& args, IndexSequence<Indexes...> const&) {
-  return make_tuple(function(get<Indexes>(forward<Tuple>(args)))...);
+  return make_tuple(function(get<Indexes>(std::forward<Tuple>(args)))...);
 }
 
 template <typename Function, typename Tuple>
 decltype(auto) tupleApplyFunction(Function&& function, Tuple&& args) {
-  return tupleApplyFunctionIndexes<Function, Tuple>(forward<Function>(function), forward<Tuple>(args),
+  return tupleApplyFunctionIndexes<Function, Tuple>(std::forward<Function>(function), std::forward<Tuple>(args),
       typename GenIndexSequence<0, std::tuple_size<typename std::decay<Tuple>::type>::value>::type());
 }
 
@@ -530,35 +530,35 @@ void tupleCallFunctionCaller(Function&&, Tuple&&) {}
 
 template <typename Tuple, typename Function, typename First, typename... Rest>
 void tupleCallFunctionCaller(Tuple&& t, Function&& function) {
-  tupleCallFunctionCaller<Tuple, Function, Rest...>(forward<Tuple>(t), forward<Function>(function));
-  function(get<sizeof...(Rest)>(forward<Tuple>(t)));
+  tupleCallFunctionCaller<Tuple, Function, Rest...>(std::forward<Tuple>(t), std::forward<Function>(function));
+  function(get<sizeof...(Rest)>(std::forward<Tuple>(t)));
 }
 
 template <typename Tuple, typename Function, typename... T>
 void tupleCallFunctionExpander(Tuple&& t, Function&& function, tuple<T...> const&) {
-  tupleCallFunctionCaller<Tuple, Function, T...>(forward<Tuple>(t), forward<Function>(function));
+  tupleCallFunctionCaller<Tuple, Function, T...>(std::forward<Tuple>(t), std::forward<Function>(function));
 }
 
 template <typename Tuple, typename Function>
 void tupleCallFunction(Tuple&& t, Function&& function) {
-  tupleCallFunctionExpander<Tuple, Function>(forward<Tuple>(t), forward<Function>(function), forward<Tuple>(t));
+  tupleCallFunctionExpander<Tuple, Function>(std::forward<Tuple>(t), std::forward<Function>(function), std::forward<Tuple>(t));
 }
 
 // Get a subset of a tuple
 
 template <typename Tuple, size_t... Indexes>
 decltype(auto) subTupleIndexes(Tuple&& t, IndexSequence<Indexes...> const&) {
-  return make_tuple(get<Indexes>(forward<Tuple>(t))...);
+  return make_tuple(get<Indexes>(std::forward<Tuple>(t))...);
 }
 
 template <size_t Min, size_t Size, typename Tuple>
 decltype(auto) subTuple(Tuple&& t) {
-  return subTupleIndexes(forward<Tuple>(t), GenIndexSequence<Min, Size>::type());
+  return subTupleIndexes(std::forward<Tuple>(t), GenIndexSequence<Min, Size>::type());
 }
 
 template <size_t Trim, typename Tuple>
 decltype(auto) trimTuple(Tuple&& t) {
-  return subTupleIndexes(forward<Tuple>(t), typename GenIndexSequence<Trim, std::tuple_size<typename std::decay<Tuple>::type>::value>::type());
+  return subTupleIndexes(std::forward<Tuple>(t), typename GenIndexSequence<Trim, std::tuple_size<typename std::decay<Tuple>::type>::value>::type());
 }
 
 // Unpack a parameter expansion into a container
@@ -568,14 +568,14 @@ void unpackVariadicImpl(Container&) {}
 
 template <typename Container, typename TFirst, typename... TRest>
 void unpackVariadicImpl(Container& container, TFirst&& tfirst, TRest&&... trest) {
-  container.insert(container.end(), forward<TFirst>(tfirst));
-  unpackVariadicImpl(container, forward<TRest>(trest)...);
+  container.insert(container.end(), std::forward<TFirst>(tfirst));
+  unpackVariadicImpl(container, std::forward<TRest>(trest)...);
 }
 
 template <typename Container, typename... T>
 Container unpackVariadic(T&&... t) {
   Container c;
-  unpackVariadicImpl(c, forward<T>(t)...);
+  unpackVariadicImpl(c, std::forward<T>(t)...);
   return c;
 }
 
@@ -587,7 +587,7 @@ void callFunctionVariadic(Function&&) {}
 template <typename Function, typename Arg1, typename... ArgRest>
 void callFunctionVariadic(Function&& function, Arg1&& arg1, ArgRest&&... argRest) {
   function(arg1);
-  callFunctionVariadic(forward<Function>(function), forward<ArgRest>(argRest)...);
+  callFunctionVariadic(std::forward<Function>(function), std::forward<ArgRest>(argRest)...);
 }
 
 template <typename... Rest>
diff --git a/source/core/StarAssetPath.cpp b/source/core/StarAssetPath.cpp
index cb607fb..9a7833b 100644
--- a/source/core/StarAssetPath.cpp
+++ b/source/core/StarAssetPath.cpp
@@ -133,18 +133,18 @@ bool AssetPath::operator==(AssetPath const& rhs) const {
 }
 
 AssetPath::AssetPath(const char* path) {
-  *this = move(AssetPath::split(path));
+  *this = AssetPath::split(path);
 }
 
 
 AssetPath::AssetPath(String const& path) {
-  *this = move(AssetPath::split(path));
+  *this = AssetPath::split(path);
 }
 
 AssetPath::AssetPath(String&& basePath, Maybe<String>&& subPath, DirectivesGroup&& directives) {
-  this->basePath = move(basePath);
-  this->subPath = move(subPath);
-  this->directives = move(directives);
+  this->basePath = std::move(basePath);
+  this->subPath = std::move(subPath);
+  this->directives = std::move(directives);
 }
 
 AssetPath::AssetPath(String const& basePath, Maybe<String> const& subPath, DirectivesGroup const& directives) {
@@ -176,7 +176,7 @@ DataStream& operator>>(DataStream& ds, AssetPath& path) {
   String string;
   ds.read(string);
 
-  path = move(string);
+  path = std::move(string);
 
   return ds;
 }
diff --git a/source/core/StarAtomicSharedPtr.hpp b/source/core/StarAtomicSharedPtr.hpp
index e85ffd5..306192f 100644
--- a/source/core/StarAtomicSharedPtr.hpp
+++ b/source/core/StarAtomicSharedPtr.hpp
@@ -47,11 +47,11 @@ AtomicSharedPtr<T>::AtomicSharedPtr(AtomicSharedPtr const& p)
 
 template <typename T>
 AtomicSharedPtr<T>::AtomicSharedPtr(AtomicSharedPtr&& p)
-  : m_ptr(move(p.m_ptr)) {}
+  : m_ptr(std::move(p.m_ptr)) {}
 
 template <typename T>
 AtomicSharedPtr<T>::AtomicSharedPtr(SharedPtr p)
-  : m_ptr(move(p)) {}
+  : m_ptr(std::move(p)) {}
 
 template <typename T>
 auto AtomicSharedPtr<T>::load() const -> SharedPtr {
@@ -68,7 +68,7 @@ auto AtomicSharedPtr<T>::weak() const -> WeakPtr {
 template <typename T>
 void AtomicSharedPtr<T>::store(SharedPtr p) {
   SpinLocker locker(m_lock);
-  m_ptr = move(p);
+  m_ptr = std::move(p);
 }
 
 template <typename T>
@@ -105,14 +105,14 @@ AtomicSharedPtr<T>& AtomicSharedPtr<T>::operator=(AtomicSharedPtr const& p) {
 template <typename T>
 AtomicSharedPtr<T>& AtomicSharedPtr<T>::operator=(AtomicSharedPtr&& p) {
   SpinLocker locker(m_lock);
-  m_ptr = move(p.m_ptr);
+  m_ptr = std::move(p.m_ptr);
   return *this;
 }
 
 template <typename T>
 AtomicSharedPtr<T>& AtomicSharedPtr<T>::operator=(SharedPtr p) {
   SpinLocker locker(m_lock);
-  m_ptr = move(p);
+  m_ptr = std::move(p);
   return *this;
 }
 
diff --git a/source/core/StarAudio.cpp b/source/core/StarAudio.cpp
index 1718aa8..4f07d05 100644
--- a/source/core/StarAudio.cpp
+++ b/source/core/StarAudio.cpp
@@ -129,7 +129,7 @@ namespace {
     for (size_t i = 0; i < pcmData->size() / 2; ++i)
       fromByteOrder(ByteOrder::LittleEndian, pcmData->ptr() + i * 2, 2);
 
-    return WaveData{move(pcmData), wavChannels, wavSampleRate};
+    return WaveData{std::move(pcmData), wavChannels, wavSampleRate};
   }
 }
 
@@ -276,7 +276,7 @@ public:
   UncompressedAudioImpl(ByteArrayConstPtr data, unsigned channels, unsigned sampleRate) {
     m_channels = channels;
     m_sampleRate = sampleRate;
-    m_audioData = move(data);
+    m_audioData = std::move(data);
     m_memoryFile.reset(m_audioData->ptr(), m_audioData->size());
   }
 
@@ -335,7 +335,7 @@ Audio::Audio(IODevicePtr device) {
 
   if (isUncompressed(device)) {
     WaveData data = parseWav(device);
-    m_uncompressed = make_shared<UncompressedAudioImpl>(move(data.byteArray), data.channels, data.sampleRate);
+    m_uncompressed = make_shared<UncompressedAudioImpl>(std::move(data.byteArray), data.channels, data.sampleRate);
   } else {
     m_compressed = make_shared<CompressedAudioImpl>(device);
     if (!m_compressed->open())
@@ -348,7 +348,7 @@ Audio::Audio(Audio const& audio) {
 }
 
 Audio::Audio(Audio&& audio) {
-  operator=(move(audio));
+  operator=(std::move(audio));
 }
 
 Audio& Audio::operator=(Audio const& audio) {
@@ -365,8 +365,8 @@ Audio& Audio::operator=(Audio const& audio) {
 }
 
 Audio& Audio::operator=(Audio&& audio) {
-  m_compressed = move(audio.m_compressed);
-  m_uncompressed = move(audio.m_uncompressed);
+  m_compressed = std::move(audio.m_compressed);
+  m_uncompressed = std::move(audio.m_uncompressed);
   return *this;
 }
 
diff --git a/source/core/StarBTree.hpp b/source/core/StarBTree.hpp
index abd8d78..1ff53bd 100644
--- a/source/core/StarBTree.hpp
+++ b/source/core/StarBTree.hpp
@@ -284,18 +284,18 @@ template <typename Base>
 template <typename Visitor>
 void BTreeMixin<Base>::forEach(Key const& lower, Key const& upper, Visitor&& visitor) {
   if (Base::rootIsLeaf())
-    forEach(Base::loadLeaf(Base::rootPointer()), lower, upper, forward<Visitor>(visitor));
+    forEach(Base::loadLeaf(Base::rootPointer()), lower, upper, std::forward<Visitor>(visitor));
   else
-    forEach(Base::loadIndex(Base::rootPointer()), lower, upper, forward<Visitor>(visitor));
+    forEach(Base::loadIndex(Base::rootPointer()), lower, upper, std::forward<Visitor>(visitor));
 }
 
 template <typename Base>
 template <typename Visitor>
 void BTreeMixin<Base>::forAll(Visitor&& visitor) {
   if (Base::rootIsLeaf())
-    forAll(Base::loadLeaf(Base::rootPointer()), forward<Visitor>(visitor));
+    forAll(Base::loadLeaf(Base::rootPointer()), std::forward<Visitor>(visitor));
   else
-    forAll(Base::loadIndex(Base::rootPointer()), forward<Visitor>(visitor));
+    forAll(Base::loadIndex(Base::rootPointer()), std::forward<Visitor>(visitor));
 }
 
 template <typename Base>
@@ -303,9 +303,9 @@ template <typename Visitor, typename ErrorHandler>
 void BTreeMixin<Base>::recoverAll(Visitor&& visitor, ErrorHandler&& error) {
   try {
     if (Base::rootIsLeaf())
-      recoverAll(Base::loadLeaf(Base::rootPointer()), forward<Visitor>(visitor), forward<ErrorHandler>(error));
+      recoverAll(Base::loadLeaf(Base::rootPointer()), std::forward<Visitor>(visitor), std::forward<ErrorHandler>(error));
     else
-      recoverAll(Base::loadIndex(Base::rootPointer()), forward<Visitor>(visitor), forward<ErrorHandler>(error));
+      recoverAll(Base::loadIndex(Base::rootPointer()), std::forward<Visitor>(visitor), std::forward<ErrorHandler>(error));
   } catch (std::exception const& e) {
     error("Error loading root index or leaf node", e);
   }
@@ -317,17 +317,17 @@ void BTreeMixin<Base>::forAllNodes(Visitor&& visitor) {
   if (Base::rootIsLeaf())
     visitor(Base::loadLeaf(Base::rootPointer()));
   else
-    forAllNodes(Base::loadIndex(Base::rootPointer()), forward<Visitor>(visitor));
+    forAllNodes(Base::loadIndex(Base::rootPointer()), std::forward<Visitor>(visitor));
 }
 
 template <typename Base>
 bool BTreeMixin<Base>::insert(Key k, Data data) {
-  return modify(DataElement{move(k), move(data)}, InsertAction);
+  return modify(DataElement{std::move(k), std::move(data)}, InsertAction);
 }
 
 template <typename Base>
 bool BTreeMixin<Base>::remove(Key k) {
-  return modify(DataElement{move(k), Data()}, RemoveAction);
+  return modify(DataElement{std::move(k), Data()}, RemoveAction);
 }
 
 template <typename Base>
@@ -422,7 +422,7 @@ bool BTreeMixin<Base>::LeafCounter::operator()(Leaf const&) {
 
 template <typename Base>
 BTreeMixin<Base>::ModifyInfo::ModifyInfo(ModifyAction a, DataElement e)
-  : targetElement(move(e)), action(a) {
+  : targetElement(std::move(e)), action(a) {
   found = false;
   state = Done;
 }
@@ -466,9 +466,9 @@ auto BTreeMixin<Base>::forEach(Index const& index, Key const& lower, Key const&
   Key lastKey;
 
   if (Base::indexLevel(index) == 0)
-    lastKey = forEach(Base::loadLeaf(Base::indexPointer(index, i)), lower, upper, forward<Visitor>(o));
+    lastKey = forEach(Base::loadLeaf(Base::indexPointer(index, i)), lower, upper, std::forward<Visitor>(o));
   else
-    lastKey = forEach(Base::loadIndex(Base::indexPointer(index, i)), lower, upper, forward<Visitor>(o));
+    lastKey = forEach(Base::loadIndex(Base::indexPointer(index, i)), lower, upper, std::forward<Visitor>(o));
 
   if (!(lastKey < upper))
     return lastKey;
@@ -483,9 +483,9 @@ auto BTreeMixin<Base>::forEach(Index const& index, Key const& lower, Key const&
       continue;
 
     if (Base::indexLevel(index) == 0)
-      lastKey = forEach(Base::loadLeaf(Base::indexPointer(index, i)), lower, upper, forward<Visitor>(o));
+      lastKey = forEach(Base::loadLeaf(Base::indexPointer(index, i)), lower, upper, std::forward<Visitor>(o));
     else
-      lastKey = forEach(Base::loadIndex(Base::indexPointer(index, i)), lower, upper, forward<Visitor>(o));
+      lastKey = forEach(Base::loadIndex(Base::indexPointer(index, i)), lower, upper, std::forward<Visitor>(o));
 
     if (!(lastKey < upper))
       break;
@@ -530,9 +530,9 @@ auto BTreeMixin<Base>::forAll(Index const& index, Visitor&& o) -> Key {
       continue;
 
     if (Base::indexLevel(index) == 0)
-      lastKey = forAll(Base::loadLeaf(Base::indexPointer(index, i)), forward<Visitor>(o));
+      lastKey = forAll(Base::loadLeaf(Base::indexPointer(index, i)), std::forward<Visitor>(o));
     else
-      lastKey = forAll(Base::loadIndex(Base::indexPointer(index, i)), forward<Visitor>(o));
+      lastKey = forAll(Base::loadIndex(Base::indexPointer(index, i)), std::forward<Visitor>(o));
   }
 
   return lastKey;
@@ -550,7 +550,7 @@ auto BTreeMixin<Base>::forAll(Leaf const& leaf, Visitor&& o) -> Key {
   }
 
   if (auto nextLeafPointer = Base::nextLeaf(leaf))
-    return forAll(Base::loadLeaf(*nextLeafPointer), forward<Visitor>(o));
+    return forAll(Base::loadLeaf(*nextLeafPointer), std::forward<Visitor>(o));
   else
     return Base::leafKey(leaf, Base::leafElementCount(leaf) - 1);
 }
@@ -562,13 +562,13 @@ void BTreeMixin<Base>::recoverAll(Index const& index, Visitor&& visitor, ErrorHa
     for (size_t i = 0; i < Base::indexPointerCount(index); ++i) {
       if (Base::indexLevel(index) == 0) {
         try {
-          recoverAll(Base::loadLeaf(Base::indexPointer(index, i)), forward<Visitor>(visitor), forward<ErrorHandler>(error));
+          recoverAll(Base::loadLeaf(Base::indexPointer(index, i)), std::forward<Visitor>(visitor), std::forward<ErrorHandler>(error));
         } catch (std::exception const& e) {
           error("Error loading leaf node", e);
         }
       } else {
         try {
-          recoverAll(Base::loadIndex(Base::indexPointer(index, i)), forward<Visitor>(visitor), forward<ErrorHandler>(error));
+          recoverAll(Base::loadIndex(Base::indexPointer(index, i)), std::forward<Visitor>(visitor), std::forward<ErrorHandler>(error));
         } catch (std::exception const& e) {
           error("Error loading index node", e);
         }
@@ -608,7 +608,7 @@ void BTreeMixin<Base>::modify(Leaf& leafNode, ModifyInfo& info) {
     return;
 
   if (info.action == InsertAction)
-    Base::leafInsert(leafNode, i, info.targetElement.key, move(info.targetElement.data));
+    Base::leafInsert(leafNode, i, info.targetElement.key, std::move(info.targetElement.data));
 
   auto splitResult = Base::leafSplit(leafNode);
   if (splitResult) {
@@ -677,26 +677,26 @@ void BTreeMixin<Base>::modify(Index& indexNode, ModifyInfo& info) {
       } else if (Base::leafElementCount(rightLeaf) == 0) {
         // Leaves merged.
         Base::setNextLeaf(leftLeaf, Base::nextLeaf(rightLeaf));
-        Base::deleteLeaf(move(rightLeaf));
+        Base::deleteLeaf(std::move(rightLeaf));
 
         // Replace two sibling pointer elements with one pointing to merged
         // leaf.
         if (left != 0)
           Base::indexUpdateKeyBefore(indexNode, left, Base::leafKey(leftLeaf, 0));
 
-        Base::indexUpdatePointer(indexNode, left, Base::storeLeaf(move(leftLeaf)));
+        Base::indexUpdatePointer(indexNode, left, Base::storeLeaf(std::move(leftLeaf)));
         Base::indexRemoveBefore(indexNode, right);
 
         selfUpdated = true;
       } else {
         // Leaves shifted.
-        Base::indexUpdatePointer(indexNode, left, Base::storeLeaf(move(leftLeaf)));
+        Base::indexUpdatePointer(indexNode, left, Base::storeLeaf(std::move(leftLeaf)));
 
         // Right leaf first key changes on shift, so always need to update
         // left index node.
         Base::indexUpdateKeyBefore(indexNode, right, Base::leafKey(rightLeaf, 0));
 
-        Base::indexUpdatePointer(indexNode, right, Base::storeLeaf(move(rightLeaf)));
+        Base::indexUpdatePointer(indexNode, right, Base::storeLeaf(std::move(rightLeaf)));
 
         selfUpdated = true;
       }
@@ -725,25 +725,25 @@ void BTreeMixin<Base>::modify(Index& indexNode, ModifyInfo& info) {
 
       } else if (Base::indexPointerCount(rightIndex) == 0) {
         // Indexes merged.
-        Base::deleteIndex(move(rightIndex));
+        Base::deleteIndex(std::move(rightIndex));
 
         // Replace two sibling pointer elements with one pointing to merged
         // index.
         if (left != 0)
           Base::indexUpdateKeyBefore(indexNode, left, getLeftKey(leftIndex));
 
-        Base::indexUpdatePointer(indexNode, left, Base::storeIndex(move(leftIndex)));
+        Base::indexUpdatePointer(indexNode, left, Base::storeIndex(std::move(leftIndex)));
         Base::indexRemoveBefore(indexNode, right);
 
         selfUpdated = true;
       } else {
         // Indexes shifted.
-        Base::indexUpdatePointer(indexNode, left, Base::storeIndex(move(leftIndex)));
+        Base::indexUpdatePointer(indexNode, left, Base::storeIndex(std::move(leftIndex)));
 
         // Right index first key changes on shift, so always need to update
         // right index node.
         Key keyForRight = getLeftKey(rightIndex);
-        Base::indexUpdatePointer(indexNode, right, Base::storeIndex(move(rightIndex)));
+        Base::indexUpdatePointer(indexNode, right, Base::storeIndex(std::move(rightIndex)));
         Base::indexUpdateKeyBefore(indexNode, right, keyForRight);
 
         selfUpdated = true;
@@ -752,19 +752,19 @@ void BTreeMixin<Base>::modify(Index& indexNode, ModifyInfo& info) {
   }
 
   if (info.state == LeafSplit) {
-    Base::indexUpdatePointer(indexNode, i, Base::storeLeaf(move(lowerLeaf)));
+    Base::indexUpdatePointer(indexNode, i, Base::storeLeaf(std::move(lowerLeaf)));
     Base::indexInsertAfter(indexNode, i, info.newKey, info.newPointer);
     selfUpdated = true;
   }
 
   if (info.state == IndexSplit) {
-    Base::indexUpdatePointer(indexNode, i, Base::storeIndex(move(lowerIndex)));
+    Base::indexUpdatePointer(indexNode, i, Base::storeIndex(std::move(lowerIndex)));
     Base::indexInsertAfter(indexNode, i, info.newKey, info.newPointer);
     selfUpdated = true;
   }
 
   if (info.state == LeafNeedsUpdate) {
-    Pointer lowerLeafPointer = Base::storeLeaf(move(lowerLeaf));
+    Pointer lowerLeafPointer = Base::storeLeaf(std::move(lowerLeaf));
     if (lowerLeafPointer != Base::indexPointer(indexNode, i)) {
       Base::indexUpdatePointer(indexNode, i, lowerLeafPointer);
       selfUpdated = true;
@@ -772,7 +772,7 @@ void BTreeMixin<Base>::modify(Index& indexNode, ModifyInfo& info) {
   }
 
   if (info.state == IndexNeedsUpdate) {
-    Pointer lowerIndexPointer = Base::storeIndex(move(lowerIndex));
+    Pointer lowerIndexPointer = Base::storeIndex(std::move(lowerIndex));
     if (lowerIndexPointer != Base::indexPointer(indexNode, i)) {
       Base::indexUpdatePointer(indexNode, i, lowerIndexPointer);
       selfUpdated = true;
@@ -796,7 +796,7 @@ void BTreeMixin<Base>::modify(Index& indexNode, ModifyInfo& info) {
 
 template <typename Base>
 bool BTreeMixin<Base>::modify(DataElement e, ModifyAction action) {
-  ModifyInfo info(action, move(e));
+  ModifyInfo info(action, std::move(e));
 
   Leaf lowerLeaf;
   Index lowerIndex;
@@ -816,7 +816,7 @@ bool BTreeMixin<Base>::modify(DataElement e, ModifyAction action) {
       // removes until setNewRoot)
       Pointer pointer = Base::indexPointer(lowerIndex, 0);
       size_t level = Base::indexLevel(lowerIndex);
-      Base::deleteIndex(move(lowerIndex));
+      Base::deleteIndex(std::move(lowerIndex));
       Base::setNewRoot(pointer, level == 0);
     } else {
       // Else just update.
@@ -833,24 +833,24 @@ bool BTreeMixin<Base>::modify(DataElement e, ModifyAction action) {
     Index newRoot;
     if (info.state == IndexSplit) {
       auto rootIndexLevel = Base::indexLevel(lowerIndex) + 1;
-      newRoot = Base::createIndex(Base::storeIndex(move(lowerIndex)));
+      newRoot = Base::createIndex(Base::storeIndex(std::move(lowerIndex)));
       Base::setIndexLevel(newRoot, rootIndexLevel);
     } else {
-      newRoot = Base::createIndex(Base::storeLeaf(move(lowerLeaf)));
+      newRoot = Base::createIndex(Base::storeLeaf(std::move(lowerLeaf)));
       Base::setIndexLevel(newRoot, 0);
     }
     Base::indexInsertAfter(newRoot, 0, info.newKey, info.newPointer);
-    Base::setNewRoot(Base::storeIndex(move(newRoot)), false);
+    Base::setNewRoot(Base::storeIndex(std::move(newRoot)), false);
   }
 
   if (info.state == IndexNeedsUpdate) {
-    Pointer newRootPointer = Base::storeIndex(move(lowerIndex));
+    Pointer newRootPointer = Base::storeIndex(std::move(lowerIndex));
     if (newRootPointer != Base::rootPointer())
       Base::setNewRoot(newRootPointer, false);
   }
 
   if (info.state == LeafNeedsUpdate) {
-    Pointer newRootPointer = Base::storeLeaf(move(lowerLeaf));
+    Pointer newRootPointer = Base::storeLeaf(std::move(lowerLeaf));
     if (newRootPointer != Base::rootPointer())
       Base::setNewRoot(newRootPointer, true);
   }
@@ -876,7 +876,7 @@ void BTreeMixin<Base>::forAllNodes(Index const& index, Visitor&& visitor) {
 
   for (size_t i = 0; i < Base::indexPointerCount(index); ++i) {
     if (Base::indexLevel(index) != 0) {
-      forAllNodes(Base::loadIndex(Base::indexPointer(index, i)), forward<Visitor>(visitor));
+      forAllNodes(Base::loadIndex(Base::indexPointer(index, i)), std::forward<Visitor>(visitor));
     } else {
       if (!visitor(Base::loadLeaf(Base::indexPointer(index, i))))
         return;
diff --git a/source/core/StarBTreeDatabase.cpp b/source/core/StarBTreeDatabase.cpp
index 4ac321f..b188f20 100644
--- a/source/core/StarBTreeDatabase.cpp
+++ b/source/core/StarBTreeDatabase.cpp
@@ -58,7 +58,7 @@ String BTreeDatabase::contentIdentifier() const {
 void BTreeDatabase::setContentIdentifier(String contentIdentifier) {
   WriteLocker writeLocker(m_lock);
   checkIfOpen("setContentIdentifier", false);
-  m_contentIdentifier = move(contentIdentifier);
+  m_contentIdentifier = std::move(contentIdentifier);
 }
 
 uint32_t BTreeDatabase::indexCacheSize() const {
@@ -91,7 +91,7 @@ IODevicePtr BTreeDatabase::ioDevice() const {
 void BTreeDatabase::setIODevice(IODevicePtr device) {
   WriteLocker writeLocker(m_lock);
   checkIfOpen("setIODevice", false);
-  m_device = move(device);
+  m_device = std::move(device);
 }
 
 bool BTreeDatabase::isOpen() const {
@@ -188,12 +188,12 @@ void BTreeDatabase::forEach(ByteArray const& lower, ByteArray const& upper, func
   ReadLocker readLocker(m_lock);
   checkKeySize(lower);
   checkKeySize(upper);
-  m_impl.forEach(lower, upper, move(v));
+  m_impl.forEach(lower, upper, std::move(v));
 }
 
 void BTreeDatabase::forAll(function<void(ByteArray, ByteArray)> v) {
   ReadLocker readLocker(m_lock);
-  m_impl.forAll(move(v));
+  m_impl.forAll(std::move(v));
 }
 
 bool BTreeDatabase::insert(ByteArray const& k, ByteArray const& data) {
@@ -445,7 +445,7 @@ ByteArray const& BTreeDatabase::LeafNode::data(size_t i) const {
 }
 
 void BTreeDatabase::LeafNode::insert(size_t i, ByteArray k, ByteArray d) {
-  elements.insertAt(i, Element{move(k), move(d)});
+  elements.insertAt(i, Element{std::move(k), std::move(d)});
 }
 
 void BTreeDatabase::LeafNode::remove(size_t i) {
@@ -855,7 +855,7 @@ auto BTreeDatabase::BTreeImpl::leafData(Leaf const& leaf, size_t i) -> Data {
 }
 
 void BTreeDatabase::BTreeImpl::leafInsert(Leaf& leaf, size_t i, Key k, Data d) {
-  leaf->insert(i, move(k), move(d));
+  leaf->insert(i, std::move(k), std::move(d));
 }
 
 void BTreeDatabase::BTreeImpl::leafRemove(Leaf& leaf, size_t i) {
diff --git a/source/core/StarBlockAllocator.hpp b/source/core/StarBlockAllocator.hpp
index 5051e66..23e0201 100644
--- a/source/core/StarBlockAllocator.hpp
+++ b/source/core/StarBlockAllocator.hpp
@@ -142,7 +142,7 @@ T* BlockAllocator<T, BlockSize>::allocate(size_t n) {
         auto sortedPosition = std::lower_bound(m_data->blocks.begin(), m_data->blocks.end(), block.get(), [](std::unique_ptr<Block> const& a, Block* b) {
             return a.get() < b;
           });
-        m_data->blocks.insert(sortedPosition, move(block));
+        m_data->blocks.insert(sortedPosition, std::move(block));
       }
     }
 
@@ -183,7 +183,7 @@ void BlockAllocator<T, BlockSize>::deallocate(T* p, size_t n) {
 template <typename T, size_t BlockSize>
 template <typename... Args>
 void BlockAllocator<T, BlockSize>::construct(pointer p, Args&&... args) const {
-  new (p) T(forward<Args>(args)...);
+  new (p) T(std::forward<Args>(args)...);
 }
 
 template <typename T, size_t BlockSize>
diff --git a/source/core/StarBuffer.cpp b/source/core/StarBuffer.cpp
index 3212e0a..0d998af 100644
--- a/source/core/StarBuffer.cpp
+++ b/source/core/StarBuffer.cpp
@@ -17,7 +17,7 @@ Buffer::Buffer(size_t initialSize)
 
 Buffer::Buffer(ByteArray b)
   : Buffer() {
-  reset(move(b));
+  reset(std::move(b));
 }
 
 Buffer::Buffer(Buffer const& buffer)
@@ -27,7 +27,7 @@ Buffer::Buffer(Buffer const& buffer)
 
 Buffer::Buffer(Buffer&& buffer)
   : Buffer() {
-  operator=(move(buffer));
+  operator=(std::move(buffer));
 }
 
 StreamOffset Buffer::pos() {
@@ -106,7 +106,7 @@ ByteArray const& Buffer::data() const {
 }
 
 ByteArray Buffer::takeData() {
-  ByteArray ret = move(m_bytes);
+  ByteArray ret = std::move(m_bytes);
   reset(0);
   return ret;
 }
@@ -143,7 +143,7 @@ void Buffer::reset(size_t newSize) {
 
 void Buffer::reset(ByteArray b) {
   m_pos = 0;
-  m_bytes = move(b);
+  m_bytes = std::move(b);
 }
 
 Buffer& Buffer::operator=(Buffer const& buffer) {
@@ -156,7 +156,7 @@ Buffer& Buffer::operator=(Buffer const& buffer) {
 Buffer& Buffer::operator=(Buffer&& buffer) {
   IODevice::operator=(buffer);
   m_pos = buffer.m_pos;
-  m_bytes = move(buffer.m_bytes);
+  m_bytes = std::move(buffer.m_bytes);
 
   buffer.m_pos = 0;
   buffer.m_bytes = ByteArray();
diff --git a/source/core/StarByteArray.cpp b/source/core/StarByteArray.cpp
index 6414c46..c764bce 100644
--- a/source/core/StarByteArray.cpp
+++ b/source/core/StarByteArray.cpp
@@ -43,7 +43,7 @@ ByteArray::ByteArray(ByteArray const& b)
 
 ByteArray::ByteArray(ByteArray&& b) noexcept
   : ByteArray() {
-  operator=(move(b));
+  operator=(std::move(b));
 }
 
 ByteArray::~ByteArray() {
diff --git a/source/core/StarColor.cpp b/source/core/StarColor.cpp
index 0c10b9d..2137a36 100644
--- a/source/core/StarColor.cpp
+++ b/source/core/StarColor.cpp
@@ -625,7 +625,7 @@ Vec4B Color::hexToVec4B(StringView s) {
     throw ColorException(strf("Improper size {} for hex string '{}' in Color::hexToVec4B", s.utf8Size(), s), false);
   }
 
-  return Vec4B(move(cbytes));
+  return Vec4B(std::move(cbytes));
 }
 
 }
diff --git a/source/core/StarCompression.cpp b/source/core/StarCompression.cpp
index 2aaf17f..2aa59b2 100644
--- a/source/core/StarCompression.cpp
+++ b/source/core/StarCompression.cpp
@@ -108,7 +108,7 @@ CompressedFile::CompressedFile()
 
 CompressedFile::CompressedFile(String filename)
   : IODevice(IOMode::Closed), m_file(0), m_compression(MediumCompression) {
-  setFilename(move(filename));
+  setFilename(std::move(filename));
 }
 
 CompressedFile::~CompressedFile() {
@@ -172,7 +172,7 @@ size_t CompressedFile::write(const char* data, size_t len) {
 void CompressedFile::setFilename(String filename) {
   if (isOpen())
     throw IOException("Cannot call setFilename while CompressedFile is open");
-  m_filename = move(filename);
+  m_filename = std::move(filename);
 }
 
 void CompressedFile::setCompression(CompressionLevel compression) {
diff --git a/source/core/StarDataStream.cpp b/source/core/StarDataStream.cpp
index 834f4de..18456b6 100644
--- a/source/core/StarDataStream.cpp
+++ b/source/core/StarDataStream.cpp
@@ -294,7 +294,7 @@ DataStream& DataStream::operator>>(ByteArray& d) {
 DataStream& DataStream::operator>>(String& s) {
   std::string string;
   operator>>(string);
-  s = move(string);
+  s = std::move(string);
   return *this;
 }
 
diff --git a/source/core/StarDataStream.hpp b/source/core/StarDataStream.hpp
index 2508a00..c8cd805 100644
--- a/source/core/StarDataStream.hpp
+++ b/source/core/StarDataStream.hpp
@@ -358,7 +358,7 @@ void DataStream::readMapContainer(Container& map, ReadFunction function) {
     typename Container::key_type key;
     typename Container::mapped_type mapped;
     function(*this, key, mapped);
-    map.insert(make_pair(move(key), move(mapped)));
+    map.insert(make_pair(std::move(key), std::move(mapped)));
   }
 }
 
diff --git a/source/core/StarDataStreamDevices.cpp b/source/core/StarDataStreamDevices.cpp
index 85e6d3f..58ec920 100644
--- a/source/core/StarDataStreamDevices.cpp
+++ b/source/core/StarDataStreamDevices.cpp
@@ -3,7 +3,7 @@
 namespace Star {
 
 DataStreamFunctions::DataStreamFunctions(function<size_t(char*, size_t)> reader, function<size_t(char const*, size_t)> writer)
-  : m_reader(move(reader)), m_writer(move(writer)) {}
+  : m_reader(std::move(reader)), m_writer(std::move(writer)) {}
 
 void DataStreamFunctions::readData(char* data, size_t len) {
   if (!m_reader)
@@ -18,7 +18,7 @@ void DataStreamFunctions::writeData(char const* data, size_t len) {
 }
 
 DataStreamIODevice::DataStreamIODevice(IODevicePtr device)
-  : m_device(move(device)) {}
+  : m_device(std::move(device)) {}
 
 IODevicePtr const& DataStreamIODevice::device() const {
   return m_device;
@@ -119,7 +119,7 @@ void DataStreamBuffer::reset(size_t newSize) {
 }
 
 void DataStreamBuffer::reset(ByteArray b) {
-  m_buffer->reset(move(b));
+  m_buffer->reset(std::move(b));
 }
 
 void DataStreamBuffer::readData(char* data, size_t len) {
diff --git a/source/core/StarDataStreamDevices.hpp b/source/core/StarDataStreamDevices.hpp
index 4a12d24..cec315e 100644
--- a/source/core/StarDataStreamDevices.hpp
+++ b/source/core/StarDataStreamDevices.hpp
@@ -184,66 +184,66 @@ ByteArray DataStreamBuffer::serializeMapContainer(T const& t, WriteFunction writ
 
 template <typename T>
 void DataStreamBuffer::deserialize(T& t, ByteArray data) {
-  DataStreamBuffer ds(move(data));
+  DataStreamBuffer ds(std::move(data));
   ds.read(t);
 }
 
 template <typename T>
 void DataStreamBuffer::deserializeContainer(T& t, ByteArray data) {
-  DataStreamBuffer ds(move(data));
+  DataStreamBuffer ds(std::move(data));
   ds.readContainer(t);
 }
 
 template <typename T, typename ReadFunction>
 void DataStreamBuffer::deserializeContainer(T& t, ByteArray data, ReadFunction readFunction) {
-  DataStreamBuffer ds(move(data));
+  DataStreamBuffer ds(std::move(data));
   ds.readContainer(t, readFunction);
 }
 
 template <typename T>
 void DataStreamBuffer::deserializeMapContainer(T& t, ByteArray data) {
-  DataStreamBuffer ds(move(data));
+  DataStreamBuffer ds(std::move(data));
   ds.readMapContainer(t);
 }
 
 template <typename T, typename ReadFunction>
 void DataStreamBuffer::deserializeMapContainer(T& t, ByteArray data, ReadFunction readFunction) {
-  DataStreamBuffer ds(move(data));
+  DataStreamBuffer ds(std::move(data));
   ds.readMapContainer(t, readFunction);
 }
 
 template <typename T>
 T DataStreamBuffer::deserialize(ByteArray data) {
   T t;
-  deserialize(t, move(data));
+  deserialize(t, std::move(data));
   return t;
 }
 
 template <typename T>
 T DataStreamBuffer::deserializeContainer(ByteArray data) {
   T t;
-  deserializeContainer(t, move(data));
+  deserializeContainer(t, std::move(data));
   return t;
 }
 
 template <typename T, typename ReadFunction>
 T DataStreamBuffer::deserializeContainer(ByteArray data, ReadFunction readFunction) {
   T t;
-  deserializeContainer(t, move(data), readFunction);
+  deserializeContainer(t, std::move(data), readFunction);
   return t;
 }
 
 template <typename T>
 T DataStreamBuffer::deserializeMapContainer(ByteArray data) {
   T t;
-  deserializeMapContainer(t, move(data));
+  deserializeMapContainer(t, std::move(data));
   return t;
 }
 
 template <typename T, typename ReadFunction>
 T DataStreamBuffer::deserializeMapContainer(ByteArray data, ReadFunction readFunction) {
   T t;
-  deserializeMapContainer(t, move(data), readFunction);
+  deserializeMapContainer(t, std::move(data), readFunction);
   return t;
 }
 
diff --git a/source/core/StarDataStreamExtra.hpp b/source/core/StarDataStreamExtra.hpp
index c0965a9..3c8565a 100644
--- a/source/core/StarDataStreamExtra.hpp
+++ b/source/core/StarDataStreamExtra.hpp
@@ -293,7 +293,7 @@ void readMaybe(DataStream& ds, Maybe<T>& maybe, ReadFunction&& readFunction) {
   if (set) {
     T t;
     readFunction(ds, t);
-    maybe = move(t);
+    maybe = std::move(t);
   } else {
     maybe.reset();
   }
diff --git a/source/core/StarDirectives.cpp b/source/core/StarDirectives.cpp
index 6c335a5..5d5266f 100644
--- a/source/core/StarDirectives.cpp
+++ b/source/core/StarDirectives.cpp
@@ -7,7 +7,7 @@
 namespace Star {
 
 Directives::Entry::Entry(ImageOperation&& newOperation, size_t strBegin, size_t strLength) {
-  operation = move(newOperation);
+  operation = std::move(newOperation);
   begin = strBegin;
   length = strLength;
 }
@@ -43,8 +43,8 @@ bool Directives::Shared::empty() const {
 }
 
 Directives::Shared::Shared(List<Entry>&& givenEntries, String&& givenString, StringView givenPrefix) {
-  entries = move(givenEntries);
-  string = move(givenString);
+  entries = std::move(givenEntries);
+  string = std::move(givenString);
   prefix = givenPrefix;
   hash = XXH3_64bits(string.utf8Ptr(), string.utf8Size());
 }
@@ -56,7 +56,7 @@ Directives::Directives(String const& directives) {
 }
 
 Directives::Directives(String&& directives) {
-  parse(move(directives));
+  parse(std::move(directives));
 }
 
 Directives::Directives(const char* directives) {
@@ -64,7 +64,7 @@ Directives::Directives(const char* directives) {
 }
 
 Directives::Directives(Directives&& directives) {
-  *this = move(directives);
+  *this = std::move(directives);
 }
 
 Directives::Directives(Directives const& directives) {
@@ -87,7 +87,7 @@ Directives& Directives::operator=(String&& s) {
     return *this;
   }
 
-  parse(move(s));
+  parse(std::move(s));
   return *this;
 }
 
@@ -100,7 +100,7 @@ Directives& Directives::operator=(const char* s) {
 }
 
 Directives& Directives::operator=(Directives&& other) {
-  shared = move(other.shared);
+  shared = std::move(other.shared);
   return *this;
 }
 
@@ -132,7 +132,7 @@ void Directives::parse(String&& directives) {
       if (beg == 0) {
         try {
           ImageOperation operation = imageOperationFromString(split);
-          newList.emplace_back(move(operation), beg, end);
+          newList.emplace_back(std::move(operation), beg, end);
         }
         catch (StarException const& e) {
           prefix = split;
@@ -141,7 +141,7 @@ void Directives::parse(String&& directives) {
       }
       else {
         ImageOperation operation = NullImageOperation();
-        newList.emplace_back(move(operation), beg, end);
+        newList.emplace_back(std::move(operation), beg, end);
       }
     }
   });
@@ -151,7 +151,7 @@ void Directives::parse(String&& directives) {
     return;
   }
 
-  shared = std::make_shared<Shared const>(move(newList), move(directives), prefix);
+  shared = std::make_shared<Shared const>(std::move(newList), std::move(directives), prefix);
   if (view.size() < 1000) { // Pre-load short enough directives
     for (auto& entry : shared->entries)
       entry.loadOperation(*shared);
@@ -219,7 +219,7 @@ DataStream& operator>>(DataStream& ds, Directives& directives) {
   String string;
   ds.read(string);
 
-  directives.parse(move(string));
+  directives.parse(std::move(string));
 
   return ds;
 }
@@ -240,7 +240,7 @@ DirectivesGroup::DirectivesGroup(String const& directives) : m_count(0) {
 
   Directives parsed(directives);
   if (parsed) {
-    m_directives.emplace_back(move(parsed));
+    m_directives.emplace_back(std::move(parsed));
     m_count = m_directives.back().size();
   }
 }
@@ -250,9 +250,9 @@ DirectivesGroup::DirectivesGroup(String&& directives) : m_count(0) {
     return;
   }
 
-  Directives parsed(move(directives));
+  Directives parsed(std::move(directives));
   if (parsed) {
-    m_directives.emplace_back(move(parsed));
+    m_directives.emplace_back(std::move(parsed));
     m_count = m_directives.back().size();
   }
 }
@@ -372,7 +372,7 @@ DataStream& operator>>(DataStream& ds, DirectivesGroup& directivesGroup) {
   String string;
   ds.read(string);
 
-  directivesGroup = DirectivesGroup(move(string));
+  directivesGroup = DirectivesGroup(std::move(string));
 
   return ds;
 }
diff --git a/source/core/StarEither.hpp b/source/core/StarEither.hpp
index 287e4bc..bed6fd7 100644
--- a/source/core/StarEither.hpp
+++ b/source/core/StarEither.hpp
@@ -85,12 +85,12 @@ private:
 
 template <typename Value>
 EitherLeftValue<Value> makeLeft(Value value) {
-  return {move(value)};
+  return {std::move(value)};
 }
 
 template <typename Value>
 EitherRightValue<Value> makeRight(Value value) {
-  return {move(value)};
+  return {std::move(value)};
 }
 
 template <typename Left, typename Right>
@@ -98,21 +98,21 @@ Either<Left, Right>::Either() {}
 
 template <typename Left, typename Right>
 Either<Left, Right>::Either(EitherLeftValue<Left> left)
-  : m_value(move(left)) {}
+  : m_value(std::move(left)) {}
 
 template <typename Left, typename Right>
 Either<Left, Right>::Either(EitherRightValue<Right> right)
-  : m_value(move(right)) {}
+  : m_value(std::move(right)) {}
 
 template <typename Left, typename Right>
 template <typename T>
 Either<Left, Right>::Either(EitherLeftValue<T> left)
-  : Either(LeftType{move(left.value)}) {}
+  : Either(LeftType{std::move(left.value)}) {}
 
 template <typename Left, typename Right>
 template <typename T>
 Either<Left, Right>::Either(EitherRightValue<T> right)
-  : Either(RightType{move(right.value)}) {}
+  : Either(RightType{std::move(right.value)}) {}
 
 template <typename Left, typename Right>
 Either<Left, Right>::Either(Either const& rhs)
@@ -120,7 +120,7 @@ Either<Left, Right>::Either(Either const& rhs)
 
 template <typename Left, typename Right>
 Either<Left, Right>::Either(Either&& rhs)
-  : m_value(move(rhs.m_value)) {}
+  : m_value(std::move(rhs.m_value)) {}
 
 template <typename Left, typename Right>
 Either<Left, Right>& Either<Left, Right>::operator=(Either const& rhs) {
@@ -130,21 +130,21 @@ Either<Left, Right>& Either<Left, Right>::operator=(Either const& rhs) {
 
 template <typename Left, typename Right>
 Either<Left, Right>& Either<Left, Right>::operator=(Either&& rhs) {
-  m_value = move(rhs.m_value);
+  m_value = std::move(rhs.m_value);
   return *this;
 }
 
 template <typename Left, typename Right>
 template <typename T>
 Either<Left, Right>& Either<Left, Right>::operator=(EitherLeftValue<T> left) {
-  m_value = LeftType{move(left.value)};
+  m_value = LeftType{std::move(left.value)};
   return *this;
 }
 
 template <typename Left, typename Right>
 template <typename T>
 Either<Left, Right>& Either<Left, Right>::operator=(EitherRightValue<T> right) {
-  m_value = RightType{move(right.value)};
+  m_value = RightType{std::move(right.value)};
   return *this;
 }
 
@@ -160,12 +160,12 @@ bool Either<Left, Right>::isRight() const {
 
 template <typename Left, typename Right>
 void Either<Left, Right>::setLeft(Left left) {
-  m_value = LeftType{move(left)};
+  m_value = LeftType{std::move(left)};
 }
 
 template <typename Left, typename Right>
 void Either<Left, Right>::setRight(Right right) {
-  m_value = RightType{move(right)};
+  m_value = RightType{std::move(right)};
 }
 
 template <typename Left, typename Right>
diff --git a/source/core/StarException.hpp b/source/core/StarException.hpp
index 87f0571..2805c9d 100644
--- a/source/core/StarException.hpp
+++ b/source/core/StarException.hpp
@@ -79,18 +79,18 @@ void fatalException(std::exception const& e, bool showStackTrace);
   class ClassName : public BaseName {                                                                                             \
   public:                                                                                                                         \
     template <typename... Args>                                                                                                   \
-    static ClassName format(fmt::format_string<Args...> fmt, Args const&... args) {                                                               \
+    static ClassName format(fmt::format_string<Args...> fmt, Args const&... args) {                                               \
       return ClassName(strf(fmt, args...));                                                                                       \
     }                                                                                                                             \
     ClassName() : BaseName(#ClassName, std::string()) {}                                                                          \
-    explicit ClassName(std::string message, bool genStackTrace = true) : BaseName(#ClassName, move(message), genStackTrace) {}    \
+    explicit ClassName(std::string message, bool genStackTrace = true) : BaseName(#ClassName, std::move(message), genStackTrace) {} \
     explicit ClassName(std::exception const& cause) : BaseName(#ClassName, std::string(), cause) {}                               \
-    ClassName(std::string message, std::exception const& cause) : BaseName(#ClassName, move(message), cause) {}                   \
+    ClassName(std::string message, std::exception const& cause) : BaseName(#ClassName, std::move(message), cause) {}              \
                                                                                                                                   \
   protected:                                                                                                                      \
-    ClassName(char const* type, std::string message, bool genStackTrace = true) : BaseName(type, move(message), genStackTrace) {} \
+    ClassName(char const* type, std::string message, bool genStackTrace = true) : BaseName(type, std::move(message), genStackTrace) {} \
     ClassName(char const* type, std::string message, std::exception const& cause)                                                 \
-      : BaseName(type, move(message), cause) {}                                                                                   \
+      : BaseName(type, std::move(message), cause) {}                                                                              \
   }
 
 STAR_EXCEPTION(OutOfRangeException, StarException);
diff --git a/source/core/StarException_unix.cpp b/source/core/StarException_unix.cpp
index 71ffd2b..02b3cbc 100644
--- a/source/core/StarException_unix.cpp
+++ b/source/core/StarException_unix.cpp
@@ -18,7 +18,7 @@ inline StackCapture captureStack() {
 }
 
 OutputProxy outputStack(StackCapture stack) {
-  return OutputProxy([stack = move(stack)](std::ostream & os) {
+  return OutputProxy([stack = std::move(stack)](std::ostream & os) {
       char** symbols = backtrace_symbols(stack.first.ptr(), stack.second);
       for (size_t i = 0; i < stack.second; ++i) {
         os << symbols[i];
@@ -39,13 +39,13 @@ StarException::StarException() noexcept
 StarException::~StarException() noexcept {}
 
 StarException::StarException(std::string message, bool genStackTrace) noexcept
-  : StarException("StarException", move(message), genStackTrace) {}
+  : StarException("StarException", std::move(message), genStackTrace) {}
 
 StarException::StarException(std::exception const& cause) noexcept
   : StarException("StarException", std::string(), cause) {}
 
 StarException::StarException(std::string message, std::exception const& cause) noexcept
-  : StarException("StarException", move(message), cause) {}
+  : StarException("StarException", std::move(message), cause) {}
 
 const char* StarException::what() const throw() {
   if (m_whatBuffer.empty()) {
@@ -68,11 +68,11 @@ StarException::StarException(char const* type, std::string message, bool genStac
     }
   };
 
-  m_printException = bind(printException, _1, _2, type, move(message), genStackTrace ? captureStack() : Maybe<StackCapture>());
+  m_printException = bind(printException, _1, _2, type, std::move(message), genStackTrace ? captureStack() : Maybe<StackCapture>());
 }
 
 StarException::StarException(char const* type, std::string message, std::exception const& cause) noexcept
-  : StarException(type, move(message)) {
+  : StarException(type, std::move(message)) {
   auto printException = [](std::ostream& os, bool fullStacktrace, function<void(std::ostream&, bool)> self, function<void(std::ostream&, bool)> cause) {
     self(os, fullStacktrace);
     os << std::endl << "Caused by: ";
@@ -88,7 +88,7 @@ StarException::StarException(char const* type, std::string message, std::excepti
     }, _1, _2, std::string(cause.what()));
   }
 
-  m_printException = bind(printException, _1, _2, m_printException, move(printCause));
+  m_printException = bind(printException, _1, _2, m_printException, std::move(printCause));
 }
 
 std::string printException(std::exception const& e, bool fullStacktrace) {
diff --git a/source/core/StarException_windows.cpp b/source/core/StarException_windows.cpp
index b40df12..159cf3d 100644
--- a/source/core/StarException_windows.cpp
+++ b/source/core/StarException_windows.cpp
@@ -117,7 +117,7 @@ inline StackCapture captureStack() {
 }
 
 OutputProxy outputStack(StackCapture stack) {
-  return OutputProxy([stack = move(stack)](std::ostream & os) {
+  return OutputProxy([stack = std::move(stack)](std::ostream & os) {
     HANDLE process = GetCurrentProcess();
     g_dbgHelpLock.lock();
     for (size_t i = 0; i < stack.second; ++i) {
@@ -146,13 +146,13 @@ StarException::StarException() noexcept : StarException(std::string("StarExcepti
 
 StarException::~StarException() noexcept {}
 
-StarException::StarException(std::string message, bool genStackTrace) noexcept : StarException("StarException", move(message), genStackTrace) {}
+StarException::StarException(std::string message, bool genStackTrace) noexcept : StarException("StarException", std::move(message), genStackTrace) {}
 
 StarException::StarException(std::exception const& cause) noexcept
     : StarException("StarException", std::string(), cause) {}
 
 StarException::StarException(std::string message, std::exception const& cause) noexcept
-    : StarException("StarException", move(message), cause) {}
+    : StarException("StarException", std::move(message), cause) {}
 
 const char* StarException::what() const throw() {
   if (m_whatBuffer.empty()) {
@@ -176,11 +176,11 @@ StarException::StarException(char const* type, std::string message, bool genStac
     }
   };
 
-  m_printException = bind(printException, _1, _2, type, move(message), genStackTrace ? captureStack() : Maybe<StackCapture>());
+  m_printException = bind(printException, _1, _2, type, std::move(message), genStackTrace ? captureStack() : Maybe<StackCapture>());
 }
 
 StarException::StarException(char const* type, std::string message, std::exception const& cause) noexcept
-    : StarException(type, move(message)) {
+    : StarException(type, std::move(message)) {
   auto printException = [](std::ostream& os,
       bool fullStacktrace,
       function<void(std::ostream&, bool)> self,
@@ -199,7 +199,7 @@ StarException::StarException(char const* type, std::string message, std::excepti
     }, _1, _2, std::string(cause.what()));
   }
 
-  m_printException = bind(printException, _1, _2, m_printException, move(printCause));
+  m_printException = bind(printException, _1, _2, m_printException, std::move(printCause));
 }
 
 std::string printException(std::exception const& e, bool fullStacktrace) {
diff --git a/source/core/StarFile.cpp b/source/core/StarFile.cpp
index 873a10e..9153960 100644
--- a/source/core/StarFile.cpp
+++ b/source/core/StarFile.cpp
@@ -124,7 +124,7 @@ File::File()
 }
 
 File::File(String filename)
-  : IODevice(IOMode::Closed), m_filename(move(filename)), m_file(0) {}
+  : IODevice(IOMode::Closed), m_filename(std::move(filename)), m_file(0) {}
 
 File::~File() {
   close();
@@ -190,7 +190,7 @@ String File::fileName() const {
 void File::setFilename(String filename) {
   if (isOpen())
     throw IOException("Cannot call setFilename while File is open");
-  m_filename = move(filename);
+  m_filename = std::move(filename);
 }
 
 void File::remove() {
diff --git a/source/core/StarFlatHashMap.hpp b/source/core/StarFlatHashMap.hpp
index 6a8c739..111aa6b 100644
--- a/source/core/StarFlatHashMap.hpp
+++ b/source/core/StarFlatHashMap.hpp
@@ -290,12 +290,12 @@ FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::FlatHashMap(FlatHashMap const
 
 template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
 FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::FlatHashMap(FlatHashMap&& other)
-  : FlatHashMap(move(other), other.m_table.getAllocator()) {}
+  : FlatHashMap(std::move(other), other.m_table.getAllocator()) {}
 
 template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
 FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::FlatHashMap(FlatHashMap&& other, allocator_type const& alloc)
   : FlatHashMap(alloc) {
-  operator=(move(other));
+  operator=(std::move(other));
 }
 
 template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
@@ -326,7 +326,7 @@ auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::operator=(FlatHashMap co
 
 template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
 auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::operator=(FlatHashMap&& other) -> FlatHashMap& {
-  m_table = move(other.m_table);
+  m_table = std::move(other.m_table);
   return *this;
 }
 
@@ -391,7 +391,7 @@ auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::insert(value_type const&
 template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
 template <typename T, typename>
 auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::insert(T&& value) -> pair<iterator, bool> {
-  auto res = m_table.insert(TableValue(forward<T&&>(value)));
+  auto res = m_table.insert(TableValue(std::forward<T&&>(value)));
   return {iterator{res.first}, res.second};
 }
 
@@ -403,7 +403,7 @@ auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::insert(const_iterator hi
 template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
 template <typename T, typename>
 auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::insert(const_iterator, T&& value) -> iterator {
-  return insert(forward<T&&>(value)).first;
+  return insert(std::forward<T&&>(value)).first;
 }
 
 template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
@@ -422,13 +422,13 @@ void FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::insert(initializer_list<
 template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
 template <typename... Args>
 auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::emplace(Args&&... args) -> pair<iterator, bool> {
-  return insert(TableValue(forward<Args>(args)...));
+  return insert(TableValue(std::forward<Args>(args)...));
 }
 
 template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
 template <typename... Args>
 auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::emplace_hint(const_iterator hint, Args&&... args) -> iterator {
-  return insert(hint, TableValue(forward<Args>(args)...));
+  return insert(hint, TableValue(std::forward<Args>(args)...));
 }
 
 template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
@@ -480,7 +480,7 @@ auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::operator[](key_type&& ke
   auto i = m_table.find(key);
   if (i != m_table.end())
     return i->second;
-  return m_table.insert({move(key), mapped_type()}).first->second;
+  return m_table.insert({std::move(key), mapped_type()}).first->second;
 }
 
 template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
diff --git a/source/core/StarFlatHashSet.hpp b/source/core/StarFlatHashSet.hpp
index 5502a1f..51d01f7 100644
--- a/source/core/StarFlatHashSet.hpp
+++ b/source/core/StarFlatHashSet.hpp
@@ -277,12 +277,12 @@ FlatHashSet<Key, Hash, Equals, Allocator>::FlatHashSet(FlatHashSet const& other,
 
 template <typename Key, typename Hash, typename Equals, typename Allocator>
 FlatHashSet<Key, Hash, Equals, Allocator>::FlatHashSet(FlatHashSet&& other)
-  : FlatHashSet(move(other), other.m_table.getAllocator()) {}
+  : FlatHashSet(std::move(other), other.m_table.getAllocator()) {}
 
 template <typename Key, typename Hash, typename Equals, typename Allocator>
 FlatHashSet<Key, Hash, Equals, Allocator>::FlatHashSet(FlatHashSet&& other, allocator_type const& alloc)
   : FlatHashSet(alloc) {
-  operator=(move(other));
+  operator=(std::move(other));
 }
 
 template <typename Key, typename Hash, typename Equals, typename Allocator>
@@ -312,7 +312,7 @@ FlatHashSet<Key, Hash, Equals, Allocator>& FlatHashSet<Key, Hash, Equals, Alloca
 
 template <typename Key, typename Hash, typename Equals, typename Allocator>
 FlatHashSet<Key, Hash, Equals, Allocator>& FlatHashSet<Key, Hash, Equals, Allocator>::operator=(FlatHashSet&& other) {
-  m_table = move(other.m_table);
+  m_table = std::move(other.m_table);
   return *this;
 }
 
@@ -376,7 +376,7 @@ auto FlatHashSet<Key, Hash, Equals, Allocator>::insert(value_type const& value)
 
 template <typename Key, typename Hash, typename Equals, typename Allocator>
 auto FlatHashSet<Key, Hash, Equals, Allocator>::insert(value_type&& value) -> pair<iterator, bool> {
-  auto res = m_table.insert(move(value));
+  auto res = m_table.insert(std::move(value));
   return {iterator{res.first}, res.second};
 }
 
@@ -387,7 +387,7 @@ auto FlatHashSet<Key, Hash, Equals, Allocator>::insert(const_iterator i, value_t
 
 template <typename Key, typename Hash, typename Equals, typename Allocator>
 auto FlatHashSet<Key, Hash, Equals, Allocator>::insert(const_iterator, value_type&& value) -> iterator {
-  return insert(move(value)).first;
+  return insert(std::move(value)).first;
 }
 
 template <typename Key, typename Hash, typename Equals, typename Allocator>
diff --git a/source/core/StarFlatHashTable.hpp b/source/core/StarFlatHashTable.hpp
index a13e08a..e9a8680 100644
--- a/source/core/StarFlatHashTable.hpp
+++ b/source/core/StarFlatHashTable.hpp
@@ -138,7 +138,7 @@ template <typename Value, typename Key, typename GetKey, typename Hash, typename
 FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::Bucket::Bucket(Bucket&& rhs) {
   this->hash = rhs.hash;
   if (auto o = rhs.valuePtr())
-    new (&this->value) Value(move(*o));
+    new (&this->value) Value(std::move(*o));
 }
 
 template <typename Value, typename Key, typename GetKey, typename Hash, typename Equals, typename Allocator>
@@ -160,9 +160,9 @@ template <typename Value, typename Key, typename GetKey, typename Hash, typename
 auto FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::Bucket::operator=(Bucket&& rhs) -> Bucket& {
   if (auto o = rhs.valuePtr()) {
     if (auto s = valuePtr())
-      *s = move(*o);
+      *s = std::move(*o);
     else
-      new (&this->value) Value(move(*o));
+      new (&this->value) Value(std::move(*o));
   } else {
     if (auto s = valuePtr())
       s->~Value();
@@ -174,9 +174,9 @@ auto FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::Bucket::operato
 template <typename Value, typename Key, typename GetKey, typename Hash, typename Equals, typename Allocator>
 void FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::Bucket::setFilled(size_t hash, Value value) {
   if (auto s = valuePtr())
-    *s = move(value);
+    *s = std::move(value);
   else
-    new (&this->value) Value(move(value));
+    new (&this->value) Value(std::move(value));
   this->hash = hash | FilledHashBit;
 }
 
@@ -370,7 +370,7 @@ auto FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::insert(Value va
       currentBucket = hashBucket(currentBucket + 1);
 
     } else {
-      target.setFilled(hash, move(value));
+      target.setFilled(hash, std::move(value));
       ++m_filledCount;
       if (insertedBucket == NPos)
         insertedBucket = currentBucket;
@@ -392,7 +392,7 @@ auto FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::erase(const_ite
     if (auto nextPtr = nextBucket->valuePtr()) {
       if (bucketError(nextBucketIndex, nextBucket->hash) > 0) {
         currentBucket->hash = nextBucket->hash;
-        *currentBucket->valuePtr() = move(*nextPtr);
+        *currentBucket->valuePtr() = std::move(*nextPtr);
         currentBucketIndex = nextBucketIndex;
         currentBucket = nextBucket;
       } else {
@@ -548,7 +548,7 @@ void FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::checkCapacity(s
 
   for (auto& entry : oldBuckets) {
     if (auto ptr = entry.valuePtr())
-      insert(move(*ptr));
+      insert(std::move(*ptr));
   }
 }
 
diff --git a/source/core/StarFont.cpp b/source/core/StarFont.cpp
index 89503ed..8113cf9 100644
--- a/source/core/StarFont.cpp
+++ b/source/core/StarFont.cpp
@@ -130,7 +130,7 @@ std::pair<Image, Vec2I> Font::render(String::Char c) {
     }
   }
 
-  return { move(image), {slot->bitmap_left - 1, (slot->bitmap_top - height) + (m_pixelSize / 4) - 1} };
+  return { std::move(image), {slot->bitmap_left - 1, (slot->bitmap_top - height) + (m_pixelSize / 4) - 1} };
 }
 
 }
diff --git a/source/core/StarHostAddress.cpp b/source/core/StarHostAddress.cpp
index 5459a7e..0457620 100644
--- a/source/core/StarHostAddress.cpp
+++ b/source/core/StarHostAddress.cpp
@@ -20,7 +20,7 @@ Either<String, HostAddress> HostAddress::lookup(String const& address) {
   try {
     HostAddress ha;
     ha.set(address);
-    return makeRight(move(ha));
+    return makeRight(std::move(ha));
   } catch (NetworkException const& e) {
     return makeLeft(String(e.what()));
   }
@@ -35,7 +35,7 @@ HostAddress::HostAddress(String const& address) {
   if (a.isLeft())
     throw NetworkException(a.left().takeUtf8());
   else
-    *this = move(a.right());
+    *this = std::move(a.right());
 }
 
 NetworkMode HostAddress::mode() const {
@@ -211,9 +211,9 @@ size_t hash<HostAddress>::operator()(HostAddress const& address) const {
 Either<String, HostAddressWithPort> HostAddressWithPort::lookup(String const& address, uint16_t port) {
   auto hostAddress = HostAddress::lookup(address);
   if (hostAddress.isLeft())
-    return makeLeft(move(hostAddress.left()));
+    return makeLeft(std::move(hostAddress.left()));
   else
-    return makeRight(HostAddressWithPort(move(hostAddress.right()), port));
+    return makeRight(HostAddressWithPort(std::move(hostAddress.right()), port));
 }
 
 Either<String, HostAddressWithPort> HostAddressWithPort::lookupWithPort(String const& address) {
@@ -228,9 +228,9 @@ Either<String, HostAddressWithPort> HostAddressWithPort::lookupWithPort(String c
 
   auto hostAddress = HostAddress::lookup(host);
   if (hostAddress.isLeft())
-    return makeLeft(move(hostAddress.left()));
+    return makeLeft(std::move(hostAddress.left()));
 
-  return makeRight(HostAddressWithPort(move(hostAddress.right()), *portNum));
+  return makeRight(HostAddressWithPort(std::move(hostAddress.right()), *portNum));
 }
 
 HostAddressWithPort::HostAddressWithPort() : m_port(0) {}
@@ -247,14 +247,14 @@ HostAddressWithPort::HostAddressWithPort(String const& address, uint16_t port) {
   auto a = lookup(address, port);
   if (a.isLeft())
     throw NetworkException(a.left().takeUtf8());
-  *this = move(a.right());
+  *this = std::move(a.right());
 }
 
 HostAddressWithPort::HostAddressWithPort(String const& address) {
   auto a = lookupWithPort(address);
   if (a.isLeft())
     throw NetworkException(a.left().takeUtf8());
-  *this = move(a.right());
+  *this = std::move(a.right());
 }
 
 HostAddress HostAddressWithPort::address() const {
diff --git a/source/core/StarIdMap.hpp b/source/core/StarIdMap.hpp
index 1f97c55..964b899 100644
--- a/source/core/StarIdMap.hpp
+++ b/source/core/StarIdMap.hpp
@@ -101,7 +101,7 @@ auto IdMapWrapper<BaseMap>::nextId() -> IdType {
 
 template <typename BaseMap>
 void IdMapWrapper<BaseMap>::add(IdType id, MappedType mappedType) {
-  if (!BaseMap::insert(make_pair(move(id), move(mappedType))).second)
+  if (!BaseMap::insert(make_pair(std::move(id), std::move(mappedType))).second)
     throw IdMapException::format("IdMapWrapper::add(id, value) called with pre-existing id '{}'", outputAny(id));
 }
 
diff --git a/source/core/StarImage.cpp b/source/core/StarImage.cpp
index f59765a..363e156 100644
--- a/source/core/StarImage.cpp
+++ b/source/core/StarImage.cpp
@@ -219,7 +219,7 @@ Image::Image(Image const& image) : Image() {
 }
 
 Image::Image(Image&& image) : Image() {
-  operator=(move(image));
+  operator=(std::move(image));
 }
 
 Image& Image::operator=(Image const& image) {
diff --git a/source/core/StarImageProcessing.cpp b/source/core/StarImageProcessing.cpp
index bf4d01a..a98e7e5 100644
--- a/source/core/StarImageProcessing.cpp
+++ b/source/core/StarImageProcessing.cpp
@@ -201,7 +201,7 @@ ImageOperation imageOperationFromString(StringView string) {
             else if (!which || (ptr != end && ++ptr != end))
                 throw ImageOperationException(strf("Improper size for hex string '{}' in imageOperationFromString", StringView(hexPtr, hexLen)), false);
             else // we're in A of A=B. In vanilla only A=B pairs are evaluated, so only throw an exception if B is also there.
-                return move(operation);
+                return operation;
               
 
             which = !which;
diff --git a/source/core/StarInterpolation.hpp b/source/core/StarInterpolation.hpp
index 1797495..426f37d 100644
--- a/source/core/StarInterpolation.hpp
+++ b/source/core/StarInterpolation.hpp
@@ -369,7 +369,7 @@ Pos inverseLinearInterpolateLower(Iterator begin, Iterator end, Pos t, Comp&& co
   if (begin == end || std::next(begin) == end)
     return Pos();
 
-  Iterator i = std::lower_bound(std::next(begin), std::prev(end), t, forward<Comp>(comp));
+  Iterator i = std::lower_bound(std::next(begin), std::prev(end), t, std::forward<Comp>(comp));
 
   --i;
   Pos min = posGetter(*i);
@@ -396,7 +396,7 @@ Pos inverseLinearInterpolateUpper(Iterator begin, Iterator end, Pos t, Comp&& co
   if (begin == end || std::next(begin) == end)
     return Pos();
 
-  Iterator i = std::upper_bound(std::next(begin), std::prev(end), t, forward<Comp>(comp));
+  Iterator i = std::upper_bound(std::next(begin), std::prev(end), t, std::forward<Comp>(comp));
 
   --i;
   Pos min = posGetter(*i);
diff --git a/source/core/StarIterator.hpp b/source/core/StarIterator.hpp
index 7770d84..389740a 100644
--- a/source/core/StarIterator.hpp
+++ b/source/core/StarIterator.hpp
@@ -137,7 +137,7 @@ public:
   }
 
   void insert(value_type v) {
-    curr = ++cont.insert(curr, move(v));
+    curr = ++cont.insert(curr, std::move(v));
     direction = -1;
   }
 
@@ -178,7 +178,7 @@ public:
   }
 
   void setValue(value_type v) const {
-    value() = move(v);
+    value() = std::move(v);
   }
 
   value_ref next() {
diff --git a/source/core/StarJson.cpp b/source/core/StarJson.cpp
index 2892e1c..3feaf37 100644
--- a/source/core/StarJson.cpp
+++ b/source/core/StarJson.cpp
@@ -745,7 +745,7 @@ Maybe<JsonObject> Json::optQueryObject(String const& path) const {
 
 Json Json::set(String key, Json value) const {
   auto map = toObject();
-  map[move(key)] = move(value);
+  map[std::move(key)] = std::move(value);
   return map;
 }
 
@@ -760,31 +760,31 @@ Json Json::erasePath(String path) const {
 Json Json::setAll(JsonObject values) const {
   auto map = toObject();
   for (auto& p : values)
-    map[move(p.first)] = move(p.second);
+    map[std::move(p.first)] = std::move(p.second);
   return map;
 }
 
 Json Json::eraseKey(String key) const {
   auto map = toObject();
-  map.erase(move(key));
+  map.erase(std::move(key));
   return map;
 }
 
 Json Json::set(size_t index, Json value) const {
   auto array = toArray();
-  array[index] = move(value);
+  array[index] = std::move(value);
   return array;
 }
 
 Json Json::insert(size_t index, Json value) const {
   auto array = toArray();
-  array.insertAt(index, move(value));
+  array.insertAt(index, std::move(value));
   return array;
 }
 
 Json Json::append(Json value) const {
   auto array = toArray();
-  array.append(move(value));
+  array.append(std::move(value));
   return array;
 }
 
@@ -927,7 +927,7 @@ DataStream& operator>>(DataStream& os, Json& v) {
     for (size_t i = 0; i < s; ++i)
       l.append(os.read<Json>());
 
-    v = move(l);
+    v = std::move(l);
   } else if (type == Json::Type::Object) {
     JsonObject m;
     size_t s = os.readVlqU();
@@ -936,7 +936,7 @@ DataStream& operator>>(DataStream& os, Json& v) {
       m[k] = os.read<Json>();
     }
 
-    v = move(m);
+    v = std::move(m);
   }
 
   return os;
diff --git a/source/core/StarJsonBuilder.cpp b/source/core/StarJsonBuilder.cpp
index 6355666..14b45a1 100644
--- a/source/core/StarJsonBuilder.cpp
+++ b/source/core/StarJsonBuilder.cpp
@@ -15,12 +15,12 @@ void JsonBuilderStream::endObject() {
   JsonObject object;
   while (true) {
     if (isSentry()) {
-      set(Json(move(object)));
+      set(Json(std::move(object)));
       return;
     } else {
       Json v = pop();
       String k = pop().toString();
-      if (!object.insert(k, move(v)).second)
+      if (!object.insert(k, std::move(v)).second)
         throw JsonParsingException(strf("Json object contains a duplicate entry for key '{}'", k));
     }
   }
@@ -35,7 +35,7 @@ void JsonBuilderStream::endArray() {
   while (true) {
     if (isSentry()) {
       array.reverse();
-      set(Json(move(array)));
+      set(Json(std::move(array)));
       return;
     } else {
       array.append(pop());
@@ -81,7 +81,7 @@ Json JsonBuilderStream::takeTop() {
 }
 
 void JsonBuilderStream::push(Json v) {
-  m_stack.append(move(v));
+  m_stack.append(std::move(v));
 }
 
 Json JsonBuilderStream::pop() {
@@ -89,7 +89,7 @@ Json JsonBuilderStream::pop() {
 }
 
 void JsonBuilderStream::set(Json v) {
-  m_stack.last() = move(v);
+  m_stack.last() = std::move(v);
 }
 
 void JsonBuilderStream::pushSentry() {
diff --git a/source/core/StarJsonExtra.cpp b/source/core/StarJsonExtra.cpp
index ec6fe90..dcf2bf6 100644
--- a/source/core/StarJsonExtra.cpp
+++ b/source/core/StarJsonExtra.cpp
@@ -372,7 +372,7 @@ List<Color> jsonToColorList(Json const& v) {
 List<Directives> jsonToDirectivesList(Json const& v) {
   List<Directives> result;
   for (auto const& entry : v.iterateArray())
-    result.append(move(entry.toString()));
+    result.append(entry.toString());
   return result;
 }
 
diff --git a/source/core/StarJsonExtra.hpp b/source/core/StarJsonExtra.hpp
index 66d89d6..98de98b 100644
--- a/source/core/StarJsonExtra.hpp
+++ b/source/core/StarJsonExtra.hpp
@@ -262,7 +262,7 @@ MapType jsonToMapK(Json const& v, KeyConverter&& keyConvert) {
 
 template <typename MapType, typename ValueConverter>
 MapType jsonToMapV(Json const& v, ValueConverter&& valueConvert) {
-  return jsonToMapKV<MapType>(v, construct<typename MapType::key_type>(), forward<ValueConverter>(valueConvert));
+  return jsonToMapKV<MapType>(v, construct<typename MapType::key_type>(), std::forward<ValueConverter>(valueConvert));
 }
 
 template <typename MapType>
@@ -281,12 +281,12 @@ Json jsonFromMapKV(MapType const& map, KeyConverter&& keyConvert, ValueConverter
 
 template <typename MapType, typename KeyConverter>
 Json jsonFromMapK(MapType const& map, KeyConverter&& keyConvert) {
-  return jsonFromMapKV<MapType>(map, forward<KeyConverter>(keyConvert), construct<Json>());
+  return jsonFromMapKV<MapType>(map, std::forward<KeyConverter>(keyConvert), construct<Json>());
 }
 
 template <typename MapType, typename ValueConverter>
 Json jsonFromMapV(MapType const& map, ValueConverter&& valueConvert) {
-  return jsonFromMapKV<MapType>(map, construct<String>(), forward<ValueConverter>(valueConvert));
+  return jsonFromMapKV<MapType>(map, construct<String>(), std::forward<ValueConverter>(valueConvert));
 }
 
 template <typename MapType>
diff --git a/source/core/StarJsonParser.hpp b/source/core/StarJsonParser.hpp
index fc14d84..522f434 100644
--- a/source/core/StarJsonParser.hpp
+++ b/source/core/StarJsonParser.hpp
@@ -462,7 +462,7 @@ private:
   }
 
   void error(std::string msg) {
-    m_error = move(msg);
+    m_error = std::move(msg);
     throw ParsingException();
   }
 
diff --git a/source/core/StarJsonRpc.cpp b/source/core/StarJsonRpc.cpp
index f6def8f..c8b59a5 100644
--- a/source/core/StarJsonRpc.cpp
+++ b/source/core/StarJsonRpc.cpp
@@ -13,7 +13,7 @@ JsonRpc::JsonRpc() {
 void JsonRpc::registerHandler(String const& handler, JsonRpcRemoteFunction func) {
   if (m_handlers.contains(handler))
     throw JsonRpcException(strf("Handler by that name already exists '{}'", handler));
-  m_handlers.add(handler, move(func));
+  m_handlers.add(handler, std::move(func));
 }
 
 void JsonRpc::registerHandlers(JsonRpcHandlers const& handlers) {
diff --git a/source/core/StarLexicalCast.hpp b/source/core/StarLexicalCast.hpp
index abda912..7c43137 100644
--- a/source/core/StarLexicalCast.hpp
+++ b/source/core/StarLexicalCast.hpp
@@ -30,7 +30,7 @@ Maybe<Type> maybeLexicalCast(StringView s, std::ios_base::fmtflags flags = std::
   if (stream >> ch)
     return {};
 
-  return move(result);
+  return result;
 }
 
 template <typename Type>
diff --git a/source/core/StarList.hpp b/source/core/StarList.hpp
index 49d2f84..cf7c6a6 100644
--- a/source/core/StarList.hpp
+++ b/source/core/StarList.hpp
@@ -451,7 +451,7 @@ void ListMixin<BaseList>::appendAll(Container&& list) {
 template <typename BaseList>
 template <class... Args>
 auto ListMixin<BaseList>::emplaceAppend(Args&&... args) -> reference {
-  Base::emplace_back(forward<Args>(args)...);
+  Base::emplace_back(std::forward<Args>(args)...);
   return *prev(Base::end());
 }
 
@@ -558,13 +558,13 @@ size_t ListMixin<BaseList>::remove(const_reference e) {
 template <typename BaseList>
 template <typename Filter>
 void ListMixin<BaseList>::filter(Filter&& filter) {
-  Star::filter(*this, forward<Filter>(filter));
+  Star::filter(*this, std::forward<Filter>(filter));
 }
 
 template <typename BaseList>
 template <typename Comparator>
 void ListMixin<BaseList>::insertSorted(value_type e, Comparator&& comparator) {
-  auto i = std::upper_bound(Base::begin(), Base::end(), e, forward<Comparator>(comparator));
+  auto i = std::upper_bound(Base::begin(), Base::end(), e, std::forward<Comparator>(comparator));
   Base::insert(i, std::move(e));
 }
 
@@ -577,7 +577,7 @@ void ListMixin<BaseList>::insertSorted(value_type e) {
 template <typename BaseList>
 template <typename Comparator>
 bool ListMixin<BaseList>::containsSorted(value_type const& e, Comparator&& comparator) {
-  auto range = std::equal_range(Base::begin(), Base::end(), e, forward<Comparator>(comparator));
+  auto range = std::equal_range(Base::begin(), Base::end(), e, std::forward<Comparator>(comparator));
   return range.first != range.second;
 }
 
@@ -611,7 +611,7 @@ void ListMixin<BaseList>::transform(Function&& function) {
 template <typename BaseList>
 template <typename Function>
 bool ListMixin<BaseList>::any(Function&& function) const {
-  return Star::any(*this, forward<Function>(function));
+  return Star::any(*this, std::forward<Function>(function));
 }
 
 template <typename BaseList>
@@ -622,7 +622,7 @@ bool ListMixin<BaseList>::any() const {
 template <typename BaseList>
 template <typename Function>
 bool ListMixin<BaseList>::all(Function&& function) const {
-  return Star::all(*this, forward<Function>(function));
+  return Star::all(*this, std::forward<Function>(function));
 }
 
 template <typename BaseList>
@@ -633,7 +633,7 @@ bool ListMixin<BaseList>::all() const {
 template <typename BaseList>
 template <typename Comparator>
 void RandomAccessListMixin<BaseList>::sort(Comparator&& comparator) {
-  Star::sort(*this, forward<Comparator>(comparator));
+  Star::sort(*this, std::forward<Comparator>(comparator));
 }
 
 template <typename BaseList>
@@ -790,7 +790,7 @@ void FrontModifyingListMixin<BaseList>::prependAll(Container&& list) {
 template <typename BaseList>
 template <class... Args>
 auto FrontModifyingListMixin<BaseList>::emplacePrepend(Args&&... args) -> reference {
-  Base::emplace_front(forward<Args>(args)...);
+  Base::emplace_front(std::forward<Args>(args)...);
   return *Base::begin();
 }
 
@@ -839,7 +839,7 @@ template <typename Element, typename Allocator>
 template <typename Filter>
 auto List<Element, Allocator>::filtered(Filter&& filter) const -> List {
   List list(*this);
-  list.filter(forward<Filter>(filter));
+  list.filter(std::forward<Filter>(filter));
   return list;
 }
 
@@ -847,7 +847,7 @@ template <typename Element, typename Allocator>
 template <typename Comparator>
 auto List<Element, Allocator>::sorted(Comparator&& comparator) const -> List {
   List list(*this);
-  list.sort(forward<Comparator>(comparator));
+  list.sort(std::forward<Comparator>(comparator));
   return list;
 }
 
@@ -863,7 +863,7 @@ template <typename Function>
 auto List<Element, Allocator>::transformed(Function&& function) {
   List<typename std::decay<decltype(std::declval<Function>()(std::declval<reference>()))>::type> res;
   res.reserve(Base::size());
-  transformInto(res, *this, forward<Function>(function));
+  transformInto(res, *this, std::forward<Function>(function));
   return res;
 }
 
@@ -872,7 +872,7 @@ template <typename Function>
 auto List<Element, Allocator>::transformed(Function&& function) const {
   List<typename std::decay<decltype(std::declval<Function>()(std::declval<const_reference>()))>::type> res;
   res.reserve(Base::size());
-  transformInto(res, *this, forward<Function>(function));
+  transformInto(res, *this, std::forward<Function>(function));
   return res;
 }
 
@@ -899,7 +899,7 @@ template <typename Element, size_t MaxSize>
 template <typename Comparator>
 auto StaticList<Element, MaxSize>::sorted(Comparator&& comparator) const -> StaticList {
   StaticList list(*this);
-  list.sort(forward<Comparator>(comparator));
+  list.sort(std::forward<Comparator>(comparator));
   return list;
 }
 
@@ -914,7 +914,7 @@ template <typename Element, size_t MaxSize>
 template <typename Function>
 auto StaticList<Element, MaxSize>::transformed(Function&& function) {
   StaticList<typename std::decay<decltype(std::declval<Function>()(std::declval<reference>()))>::type, MaxSize> res;
-  transformInto(res, *this, forward<Function>(function));
+  transformInto(res, *this, std::forward<Function>(function));
   return res;
 }
 
@@ -922,7 +922,7 @@ template <typename Element, size_t MaxSize>
 template <typename Function>
 auto StaticList<Element, MaxSize>::transformed(Function&& function) const {
   StaticList<typename std::decay<decltype(std::declval<Function>()(std::declval<const_reference>()))>::type, MaxSize> res;
-  transformInto(res, *this, forward<Function>(function));
+  transformInto(res, *this, std::forward<Function>(function));
   return res;
 }
 
@@ -941,7 +941,7 @@ template <typename Element, size_t MaxStackSize>
 template <typename Filter>
 auto SmallList<Element, MaxStackSize>::filtered(Filter&& filter) const -> SmallList {
   SmallList list(*this);
-  list.filter(forward<Filter>(filter));
+  list.filter(std::forward<Filter>(filter));
   return list;
 }
 
@@ -949,7 +949,7 @@ template <typename Element, size_t MaxStackSize>
 template <typename Comparator>
 auto SmallList<Element, MaxStackSize>::sorted(Comparator&& comparator) const -> SmallList {
   SmallList list(*this);
-  list.sort(forward<Comparator>(comparator));
+  list.sort(std::forward<Comparator>(comparator));
   return list;
 }
 
@@ -964,7 +964,7 @@ template <typename Element, size_t MaxStackSize>
 template <typename Function>
 auto SmallList<Element, MaxStackSize>::transformed(Function&& function) {
   SmallList<typename std::decay<decltype(std::declval<Function>()(std::declval<reference>()))>::type, MaxStackSize> res;
-  transformInto(res, *this, forward<Function>(function));
+  transformInto(res, *this, std::forward<Function>(function));
   return res;
 }
 
@@ -972,7 +972,7 @@ template <typename Element, size_t MaxStackSize>
 template <typename Function>
 auto SmallList<Element, MaxStackSize>::transformed(Function&& function) const {
   SmallList<typename std::decay<decltype(std::declval<Function>()(std::declval<const_reference>()))>::type, MaxStackSize> res;
-  transformInto(res, *this, forward<Function>(function));
+  transformInto(res, *this, std::forward<Function>(function));
   return res;
 }
 
@@ -991,7 +991,7 @@ template <typename Element, typename Allocator>
 template <typename Filter>
 Deque<Element, Allocator> Deque<Element, Allocator>::filtered(Filter&& filter) const {
   Deque l(*this);
-  l.filter(forward<Filter>(filter));
+  l.filter(std::forward<Filter>(filter));
   return l;
 }
 
@@ -999,7 +999,7 @@ template <typename Element, typename Allocator>
 template <typename Comparator>
 Deque<Element, Allocator> Deque<Element, Allocator>::sorted(Comparator&& comparator) const {
   Deque l(*this);
-  l.sort(forward<Comparator>(comparator));
+  l.sort(std::forward<Comparator>(comparator));
   return l;
 }
 
@@ -1013,13 +1013,13 @@ Deque<Element, Allocator> Deque<Element, Allocator>::sorted() const {
 template <typename Element, typename Allocator>
 template <typename Function>
 auto Deque<Element, Allocator>::transformed(Function&& function) {
-  return Star::transform<Deque<decltype(std::declval<Function>()(std::declval<reference>()))>>(*this, forward<Function>(function));
+  return Star::transform<Deque<decltype(std::declval<Function>()(std::declval<reference>()))>>(*this, std::forward<Function>(function));
 }
 
 template <typename Element, typename Allocator>
 template <typename Function>
 auto Deque<Element, Allocator>::transformed(Function&& function) const {
-  return Star::transform<Deque<decltype(std::declval<Function>()(std::declval<const_reference>()))>>(*this, forward<Function>(function));
+  return Star::transform<Deque<decltype(std::declval<Function>()(std::declval<const_reference>()))>>(*this, std::forward<Function>(function));
 }
 
 template <typename Element, typename Allocator>
@@ -1064,7 +1064,7 @@ template <typename Element, typename Allocator>
 template <typename Filter>
 LinkedList<Element, Allocator> LinkedList<Element, Allocator>::filtered(Filter&& filter) const {
   LinkedList list(*this);
-  list.filter(forward<Filter>(filter));
+  list.filter(std::forward<Filter>(filter));
   return list;
 }
 
@@ -1072,7 +1072,7 @@ template <typename Element, typename Allocator>
 template <typename Comparator>
 LinkedList<Element, Allocator> LinkedList<Element, Allocator>::sorted(Comparator&& comparator) const {
   LinkedList l(*this);
-  l.sort(forward<Comparator>(comparator));
+  l.sort(std::forward<Comparator>(comparator));
   return l;
 }
 
@@ -1086,13 +1086,13 @@ LinkedList<Element, Allocator> LinkedList<Element, Allocator>::sorted() const {
 template <typename Element, typename Allocator>
 template <typename Function>
 auto LinkedList<Element, Allocator>::transformed(Function&& function) {
-  return Star::transform<LinkedList<decltype(std::declval<Function>()(std::declval<reference>()))>>(*this, forward<Function>(function));
+  return Star::transform<LinkedList<decltype(std::declval<Function>()(std::declval<reference>()))>>(*this, std::forward<Function>(function));
 }
 
 template <typename Element, typename Allocator>
 template <typename Function>
 auto LinkedList<Element, Allocator>::transformed(Function&& function) const {
-  return Star::transform<LinkedList<decltype(std::declval<Function>()(std::declval<const_reference>()))>>(*this, forward<Function>(function));
+  return Star::transform<LinkedList<decltype(std::declval<Function>()(std::declval<const_reference>()))>>(*this, std::forward<Function>(function));
 }
 
 template <typename BaseList>
diff --git a/source/core/StarListener.cpp b/source/core/StarListener.cpp
index 642f2a2..394d55d 100644
--- a/source/core/StarListener.cpp
+++ b/source/core/StarListener.cpp
@@ -5,7 +5,7 @@ namespace Star {
 Listener::~Listener() {}
 
 CallbackListener::CallbackListener(function<void()> callback)
-  : callback(move(callback)) {}
+  : callback(std::move(callback)) {}
 
 void CallbackListener::trigger() {
   if (callback)
@@ -16,12 +16,12 @@ TrackerListener::TrackerListener() : triggered(false) {}
 
 void ListenerGroup::addListener(ListenerWeakPtr listener) {
   MutexLocker locker(m_mutex);
-  m_listeners.insert(move(listener));
+  m_listeners.insert(std::move(listener));
 }
 
 void ListenerGroup::removeListener(ListenerWeakPtr listener) {
   MutexLocker locker(m_mutex);
-  m_listeners.erase(move(listener));
+  m_listeners.erase(std::move(listener));
 }
 
 void ListenerGroup::clearExpiredListeners() {
diff --git a/source/core/StarLockFile_unix.cpp b/source/core/StarLockFile_unix.cpp
index 298c636..ab43d93 100644
--- a/source/core/StarLockFile_unix.cpp
+++ b/source/core/StarLockFile_unix.cpp
@@ -12,16 +12,16 @@ namespace Star {
 int64_t const LockFile::MaximumSleepMillis;
 
 Maybe<LockFile> LockFile::acquireLock(String const& filename, int64_t lockTimeout) {
-  LockFile lock(move(filename));
+  LockFile lock(std::move(filename));
   if (lock.lock(lockTimeout))
     return lock;
   return {};
 }
 
-LockFile::LockFile(String const& filename) : m_filename(move(filename)) {}
+LockFile::LockFile(String const& filename) : m_filename(std::move(filename)) {}
 
 LockFile::LockFile(LockFile&& lockFile) {
-  operator=(move(lockFile));
+  operator=(std::move(lockFile));
 }
 
 LockFile::~LockFile() {
@@ -29,8 +29,8 @@ LockFile::~LockFile() {
 }
 
 LockFile& LockFile::operator=(LockFile&& lockFile) {
-  m_filename = move(lockFile.m_filename);
-  m_handle = move(lockFile.m_handle);
+  m_filename = std::move(lockFile.m_filename);
+  m_handle = std::move(lockFile.m_handle);
 
   return *this;
 }
diff --git a/source/core/StarLockFile_windows.cpp b/source/core/StarLockFile_windows.cpp
index 33692fb..c6d7295 100644
--- a/source/core/StarLockFile_windows.cpp
+++ b/source/core/StarLockFile_windows.cpp
@@ -11,16 +11,16 @@ namespace Star {
 int64_t const LockFile::MaximumSleepMillis;
 
 Maybe<LockFile> LockFile::acquireLock(String const& filename, int64_t lockTimeout) {
-  LockFile lock(move(filename));
+  LockFile lock(std::move(filename));
   if (lock.lock(lockTimeout))
-    return move(lock);
+    return std::move(lock);
   return {};
 }
 
-LockFile::LockFile(String const& filename) : m_filename(move(filename)) {}
+LockFile::LockFile(String const& filename) : m_filename(std::move(filename)) {}
 
 LockFile::LockFile(LockFile&& lockFile) {
-  operator=(move(lockFile));
+  operator=(std::move(lockFile));
 }
 
 LockFile::~LockFile() {
@@ -28,8 +28,8 @@ LockFile::~LockFile() {
 }
 
 LockFile& LockFile::operator=(LockFile&& lockFile) {
-  m_filename = move(lockFile.m_filename);
-  m_handle = move(lockFile.m_handle);
+  m_filename = std::move(lockFile.m_filename);
+  m_handle = std::move(lockFile.m_handle);
 
   return *this;
 }
diff --git a/source/core/StarLogging.cpp b/source/core/StarLogging.cpp
index 19094f8..062facf 100644
--- a/source/core/StarLogging.cpp
+++ b/source/core/StarLogging.cpp
@@ -212,9 +212,9 @@ void SpatialLogger::clear() {
   decltype(s_logText) logText;
   {
     MutexLocker locker(s_mutex);
-    lines = move(s_lines);
-    points = move(s_points);
-    logText = move(s_logText);
+    lines = std::move(s_lines);
+    points = std::move(s_points);
+    logText = std::move(s_logText);
   } // Move while locked to deallocate contents while unlocked.
 }
 
diff --git a/source/core/StarLruCache.hpp b/source/core/StarLruCache.hpp
index d047a37..a59ed03 100644
--- a/source/core/StarLruCache.hpp
+++ b/source/core/StarLruCache.hpp
@@ -105,9 +105,9 @@ template <typename OrderedMapType>
 void LruCacheBase<OrderedMapType>::set(Key const& key, Value value) {
   auto i = m_map.find(key);
   if (i == m_map.end()) {
-    m_map.add(key, move(value));
+    m_map.add(key, std::move(value));
   } else {
-    i->second = move(value);
+    i->second = std::move(value);
     m_map.toBack(i);
   }
 }
diff --git a/source/core/StarLua.cpp b/source/core/StarLua.cpp
index 49d54f3..84e6c82 100644
--- a/source/core/StarLua.cpp
+++ b/source/core/StarLua.cpp
@@ -76,7 +76,7 @@ StringMap<LuaDetail::LuaWrappedFunction> const& LuaCallbacks::callbacks() const
 }
 
 bool LuaContext::containsPath(String path) const {
-  return engine().contextGetPath(handleIndex(), move(path)) != LuaNil;
+  return engine().contextGetPath(handleIndex(), std::move(path)) != LuaNil;
 }
 
 void LuaContext::load(char const* contents, size_t size, char const* name) {
@@ -92,7 +92,7 @@ void LuaContext::load(ByteArray const& contents, String const& name) {
 }
 
 void LuaContext::setRequireFunction(RequireFunction requireFunction) {
-  engine().setContextRequire(handleIndex(), move(requireFunction));
+  engine().setContextRequire(handleIndex(), std::move(requireFunction));
 }
 
 void LuaContext::setCallbacks(String const& tableName, LuaCallbacks const& callbacks) const {
@@ -162,11 +162,11 @@ Maybe<Json> LuaConverter<Json>::to(LuaEngine&, LuaValue const& v) {
 }
 
 LuaValue LuaConverter<JsonObject>::from(LuaEngine& engine, JsonObject v) {
-  return engine.luaFrom<Json>(Json(move(v)));
+  return engine.luaFrom<Json>(Json(std::move(v)));
 }
 
 Maybe<JsonObject> LuaConverter<JsonObject>::to(LuaEngine& engine, LuaValue v) {
-  auto j = engine.luaTo<Json>(move(v));
+  auto j = engine.luaTo<Json>(std::move(v));
   if (j.type() == Json::Type::Object) {
     return j.toObject();
   } else if (j.type() == Json::Type::Array) {
@@ -179,11 +179,11 @@ Maybe<JsonObject> LuaConverter<JsonObject>::to(LuaEngine& engine, LuaValue v) {
 }
 
 LuaValue LuaConverter<JsonArray>::from(LuaEngine& engine, JsonArray v) {
-  return engine.luaFrom<Json>(Json(move(v)));
+  return engine.luaFrom<Json>(Json(std::move(v)));
 }
 
 Maybe<JsonArray> LuaConverter<JsonArray>::to(LuaEngine& engine, LuaValue v) {
-  auto j = engine.luaTo<Json>(move(v));
+  auto j = engine.luaTo<Json>(std::move(v));
   if (j.type() == Json::Type::Array) {
     return j.toArray();
   } else if (j.type() == Json::Type::Object) {
@@ -839,7 +839,7 @@ void LuaEngine::tableIterate(int handleIndex, function<bool(LuaValue key, LuaVal
     LuaValue value = popLuaValue(m_state);
     bool cont = false;
     try {
-      cont = iterator(move(key), move(value));
+      cont = iterator(std::move(key), std::move(value));
     } catch (...) {
       lua_pop(m_state, 2);
       throw;
@@ -881,7 +881,7 @@ void LuaEngine::setContextRequire(int handleIndex, LuaContext::RequireFunction r
   pushHandle(m_state, handleIndex);
 
   auto funcUserdata = (LuaContext::RequireFunction*)lua_newuserdata(m_state, sizeof(LuaContext::RequireFunction));
-  new (funcUserdata) LuaContext::RequireFunction(move(requireFunction));
+  new (funcUserdata) LuaContext::RequireFunction(std::move(requireFunction));
   lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_requireFunctionMetatableRegistryId);
   lua_setmetatable(m_state, -2);
 
@@ -1076,7 +1076,7 @@ LuaFunction LuaEngine::createWrappedFunction(LuaDetail::LuaWrappedFunction funct
   lua_checkstack(m_state, 2);
 
   auto funcUserdata = (LuaDetail::LuaWrappedFunction*)lua_newuserdata(m_state, sizeof(LuaDetail::LuaWrappedFunction));
-  new (funcUserdata) LuaDetail::LuaWrappedFunction(move(function));
+  new (funcUserdata) LuaDetail::LuaWrappedFunction(std::move(function));
 
   lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_wrappedFunctionMetatableRegistryId);
   lua_setmetatable(m_state, -2);
@@ -1400,7 +1400,7 @@ Maybe<Json> LuaDetail::tableToJsonContainer(LuaTable const& table) {
       if (auto i = asInteger(key)) {
         intEntries[*i] = jsonValue.take();
       } else {
-        auto stringKey = table.engine().luaMaybeTo<String>(move(key));
+        auto stringKey = table.engine().luaMaybeTo<String>(std::move(key));
         if (!stringKey) {
           failedConversion = true;
           return false;
@@ -1420,12 +1420,12 @@ Maybe<Json> LuaDetail::tableToJsonContainer(LuaTable const& table) {
   if (interpretAsList) {
     JsonArray list;
     for (auto& p : intEntries)
-      list.set(p.first - 1, move(p.second));
-    return Json(move(list));
+      list.set(p.first - 1, std::move(p.second));
+    return Json(std::move(list));
   } else {
     for (auto& p : intEntries)
-      stringEntries[toString(p.first)] = move(p.second);
-    return Json(move(stringEntries));
+      stringEntries[toString(p.first)] = std::move(p.second);
+    return Json(std::move(stringEntries));
   }
 }
 
diff --git a/source/core/StarLua.hpp b/source/core/StarLua.hpp
index affee9a..d138c8b 100644
--- a/source/core/StarLua.hpp
+++ b/source/core/StarLua.hpp
@@ -856,7 +856,7 @@ struct LuaConverter<std::string> {
   }
 
   static Maybe<std::string> to(LuaEngine& engine, LuaValue v) {
-    return engine.luaTo<String>(move(v)).takeUtf8();
+    return engine.luaTo<String>(std::move(v)).takeUtf8();
   }
 };
 
@@ -887,12 +887,12 @@ struct LuaConverter<Directives> {
 template <>
 struct LuaConverter<LuaString> {
   static LuaValue from(LuaEngine&, LuaString v) {
-    return LuaValue(move(v));
+    return LuaValue(std::move(v));
   }
 
   static Maybe<LuaString> to(LuaEngine& engine, LuaValue v) {
     if (v.is<LuaString>())
-      return LuaString(move(v.get<LuaString>()));
+      return LuaString(std::move(v.get<LuaString>()));
     if (v.is<LuaInt>())
       return engine.createString(toString(v.get<LuaInt>()));
     if (v.is<LuaFloat>())
@@ -909,7 +909,7 @@ struct LuaValueConverter {
 
   static Maybe<T> to(LuaEngine&, LuaValue v) {
     if (auto p = v.ptr<T>()) {
-      return move(*p);
+      return std::move(*p);
     }
     return {};
   }
@@ -967,7 +967,7 @@ struct LuaConverter<Maybe<T>> {
 
   static Maybe<Maybe<T>> to(LuaEngine& engine, LuaValue&& v) {
     if (v != LuaNil) {
-      if (auto conv = engine.luaMaybeTo<T>(move(v)))
+      if (auto conv = engine.luaMaybeTo<T>(std::move(v)))
         return conv;
       else
         return {};
@@ -991,8 +991,8 @@ struct LuaMapConverter {
     T result;
     bool failed = false;
     table->iterate([&result, &failed, &engine](LuaValue key, LuaValue value) {
-        auto contKey = engine.luaMaybeTo<typename T::key_type>(move(key));
-        auto contValue = engine.luaMaybeTo<typename T::mapped_type>(move(value));
+        auto contKey = engine.luaMaybeTo<typename T::key_type>(std::move(key));
+        auto contValue = engine.luaMaybeTo<typename T::mapped_type>(std::move(value));
         if (!contKey || !contValue) {
           failed = true;
           return false;
@@ -1026,7 +1026,7 @@ struct LuaContainerConverter {
           failed = true;
           return false;
         }
-        auto contVal = engine.luaMaybeTo<typename T::value_type>(move(value));
+        auto contVal = engine.luaMaybeTo<typename T::value_type>(std::move(value));
         if (!contVal) {
           failed = true;
           return false;
@@ -1086,7 +1086,7 @@ struct LuaConverter<JsonArray> {
 
 namespace LuaDetail {
   inline LuaHandle::LuaHandle(LuaEnginePtr engine, int handleIndex)
-    : engine(move(engine)), handleIndex(handleIndex) {}
+    : engine(std::move(engine)), handleIndex(handleIndex) {}
 
   inline LuaHandle::~LuaHandle() {
     if (engine)
@@ -1213,7 +1213,7 @@ namespace LuaDetail {
   struct ArgGet {
     static T get(LuaEngine& engine, size_t argc, LuaValue* argv, size_t index) {
       if (index < argc)
-        return engine.luaTo<T>(move(argv[index]));
+        return engine.luaTo<T>(std::move(argv[index]));
       return engine.luaTo<T>(LuaNil);
     }
   };
@@ -1226,7 +1226,7 @@ namespace LuaDetail {
 
       LuaVariadic<T> subargs(argc - index);
       for (size_t i = index; i < argc; ++i)
-        subargs[i - index] = engine.luaTo<T>(move(argv[i]));
+        subargs[i - index] = engine.luaTo<T>(std::move(argv[i]));
       return subargs;
     }
   };
@@ -1235,14 +1235,14 @@ namespace LuaDetail {
   struct FunctionWrapper {
     template <typename Function, size_t... Indexes>
     static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
-      return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
+      return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
         return toWrappedReturn(engine, (Return const&)func(ArgGet<Args>::get(engine, argc, argv, Indexes)...));
       };
     }
 
     template <typename Function>
     static LuaWrappedFunction wrap(Function func) {
-      return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
+      return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
     }
   };
 
@@ -1250,7 +1250,7 @@ namespace LuaDetail {
   struct FunctionWrapper<void, Args...> {
     template <typename Function, size_t... Indexes>
     static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
-      return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
+      return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
         func(ArgGet<Args>::get(engine, argc, argv, Indexes)...);
         return LuaFunctionReturn();
       };
@@ -1258,7 +1258,7 @@ namespace LuaDetail {
 
     template <typename Function>
     static LuaWrappedFunction wrap(Function func) {
-      return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
+      return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
     }
   };
 
@@ -1266,14 +1266,14 @@ namespace LuaDetail {
   struct FunctionWrapper<Return, LuaEngine, Args...> {
     template <typename Function, size_t... Indexes>
     static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
-      return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
+      return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
         return toWrappedReturn(engine, (Return const&)func(engine, ArgGet<Args>::get(engine, argc, argv, Indexes)...));
       };
     }
 
     template <typename Function>
     static LuaWrappedFunction wrap(Function func) {
-      return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
+      return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
     }
   };
 
@@ -1281,7 +1281,7 @@ namespace LuaDetail {
   struct FunctionWrapper<void, LuaEngine, Args...> {
     template <typename Function, size_t... Indexes>
     static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
-      return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
+      return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
         func(engine, ArgGet<Args>::get(engine, argc, argv, Indexes)...);
         return LuaFunctionReturn();
       };
@@ -1289,31 +1289,31 @@ namespace LuaDetail {
 
     template <typename Function>
     static LuaWrappedFunction wrap(Function func) {
-      return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
+      return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
     }
   };
 
   template <typename Return, typename... Args, typename Function>
   LuaWrappedFunction wrapFunctionWithSignature(Function&& func) {
-    return FunctionWrapper<Return, typename std::decay<Args>::type...>::wrap(forward<Function>(func));
+    return FunctionWrapper<Return, typename std::decay<Args>::type...>::wrap(std::forward<Function>(func));
   }
 
   template <typename Return, typename Function, typename... Args>
   LuaWrappedFunction wrapFunctionArgs(Function&& func, VariadicTypedef<Args...> const&) {
-    return wrapFunctionWithSignature<Return, Args...>(forward<Function>(func));
+    return wrapFunctionWithSignature<Return, Args...>(std::forward<Function>(func));
   }
 
   template <typename Function>
   LuaWrappedFunction wrapFunction(Function&& func) {
     return wrapFunctionArgs<typename FunctionTraits<Function>::Return>(
-        forward<Function>(func), typename FunctionTraits<Function>::Args());
+        std::forward<Function>(func), typename FunctionTraits<Function>::Args());
   }
 
   template <typename Return, typename T, typename... Args>
   struct MethodWrapper {
     template <typename Function, size_t... Indexes>
     static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
-      return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) mutable {
+      return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) mutable {
         if (argc == 0)
           throw LuaException("No object argument passed to wrapped method");
         return toWrappedReturn(engine,
@@ -1323,7 +1323,7 @@ namespace LuaDetail {
 
     template <typename Function>
     static LuaWrappedFunction wrap(Function&& func) {
-      return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
+      return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
     }
   };
 
@@ -1331,7 +1331,7 @@ namespace LuaDetail {
   struct MethodWrapper<void, T, Args...> {
     template <typename Function, size_t... Indexes>
     static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
-      return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
+      return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
         if (argc == 0)
           throw LuaException("No object argument passed to wrapped method");
         func(argv[0].get<LuaUserData>().get<T>(), ArgGet<Args>::get(engine, argc - 1, argv + 1, Indexes)...);
@@ -1341,7 +1341,7 @@ namespace LuaDetail {
 
     template <typename Function>
     static LuaWrappedFunction wrap(Function func) {
-      return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
+      return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
     }
   };
 
@@ -1349,7 +1349,7 @@ namespace LuaDetail {
   struct MethodWrapper<Return, T, LuaEngine, Args...> {
     template <typename Function, size_t... Indexes>
     static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
-      return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
+      return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
         if (argc == 0)
           throw LuaException("No object argument passed to wrapped method");
         return toWrappedReturn(
@@ -1360,7 +1360,7 @@ namespace LuaDetail {
 
     template <typename Function>
     static LuaWrappedFunction wrap(Function func) {
-      return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
+      return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
     }
   };
 
@@ -1368,7 +1368,7 @@ namespace LuaDetail {
   struct MethodWrapper<void, T, LuaEngine, Args...> {
     template <typename Function, size_t... Indexes>
     static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
-      return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
+      return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
         if (argc == 0)
           throw LuaException("No object argument passed to wrapped method");
         func(argv[0].get<LuaUserData>().get<T>(), engine, ArgGet<Args>::get(engine, argc - 1, argv + 1, Indexes)...);
@@ -1378,24 +1378,24 @@ namespace LuaDetail {
 
     template <typename Function>
     static LuaWrappedFunction wrap(Function func) {
-      return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
+      return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
     }
   };
 
   template <typename Return, typename... Args, typename Function>
   LuaWrappedFunction wrapMethodWithSignature(Function&& func) {
-    return MethodWrapper<Return, typename std::decay<Args>::type...>::wrap(forward<Function>(func));
+    return MethodWrapper<Return, typename std::decay<Args>::type...>::wrap(std::forward<Function>(func));
   }
 
   template <typename Return, typename Function, typename... Args>
   LuaWrappedFunction wrapMethodArgs(Function&& func, VariadicTypedef<Args...> const&) {
-    return wrapMethodWithSignature<Return, Args...>(forward<Function>(func));
+    return wrapMethodWithSignature<Return, Args...>(std::forward<Function>(func));
   }
 
   template <typename Function>
   LuaWrappedFunction wrapMethod(Function&& func) {
     return wrapMethodArgs<typename FunctionTraits<Function>::Return>(
-        forward<Function>(func), typename FunctionTraits<Function>::Args());
+        std::forward<Function>(func), typename FunctionTraits<Function>::Args());
   }
 
   template <typename Ret, typename... Args>
@@ -1405,8 +1405,8 @@ namespace LuaDetail {
   struct TableIteratorWrapper<bool, LuaEngine&, Key, Value> {
     template <typename Function>
     static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) {
-      return [&engine, func = move(func)](LuaValue key, LuaValue value) -> bool {
-        return func(engine, engine.luaTo<Key>(move(key)), engine.luaTo<Value>(move(value)));
+      return [&engine, func = std::move(func)](LuaValue key, LuaValue value) -> bool {
+        return func(engine, engine.luaTo<Key>(std::move(key)), engine.luaTo<Value>(std::move(value)));
       };
     }
   };
@@ -1415,8 +1415,8 @@ namespace LuaDetail {
   struct TableIteratorWrapper<void, LuaEngine&, Key, Value> {
     template <typename Function>
     static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) {
-      return [&engine, func = move(func)](LuaValue key, LuaValue value) -> bool {
-        func(engine, engine.luaTo<Key>(move(key)), engine.luaTo<Value>(move(value)));
+      return [&engine, func = std::move(func)](LuaValue key, LuaValue value) -> bool {
+        func(engine, engine.luaTo<Key>(std::move(key)), engine.luaTo<Value>(std::move(value)));
         return true;
       };
     }
@@ -1426,8 +1426,8 @@ namespace LuaDetail {
   struct TableIteratorWrapper<bool, Key, Value> {
     template <typename Function>
     static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) {
-      return [&engine, func = move(func)](LuaValue key, LuaValue value) -> bool {
-        return func(engine.luaTo<Key>(move(key)), engine.luaTo<Value>(move(value)));
+      return [&engine, func = std::move(func)](LuaValue key, LuaValue value) -> bool {
+        return func(engine.luaTo<Key>(std::move(key)), engine.luaTo<Value>(std::move(value)));
       };
     }
   };
@@ -1436,8 +1436,8 @@ namespace LuaDetail {
   struct TableIteratorWrapper<void, Key, Value> {
     template <typename Function>
     static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) {
-      return [&engine, func = move(func)](LuaValue key, LuaValue value) -> bool {
-        func(engine.luaTo<Key>(move(key)), engine.luaTo<Value>(move(value)));
+      return [&engine, func = std::move(func)](LuaValue key, LuaValue value) -> bool {
+        func(engine.luaTo<Key>(std::move(key)), engine.luaTo<Value>(std::move(value)));
         return true;
       };
     }
@@ -1445,19 +1445,19 @@ namespace LuaDetail {
 
   template <typename Return, typename... Args, typename Function>
   function<bool(LuaValue, LuaValue)> wrapTableIteratorWithSignature(LuaEngine& engine, Function&& func) {
-    return TableIteratorWrapper<Return, typename std::decay<Args>::type...>::wrap(engine, forward<Function>(func));
+    return TableIteratorWrapper<Return, typename std::decay<Args>::type...>::wrap(engine, std::forward<Function>(func));
   }
 
   template <typename Return, typename Function, typename... Args>
   function<bool(LuaValue, LuaValue)> wrapTableIteratorArgs(
       LuaEngine& engine, Function&& func, VariadicTypedef<Args...> const&) {
-    return wrapTableIteratorWithSignature<Return, Args...>(engine, forward<Function>(func));
+    return wrapTableIteratorWithSignature<Return, Args...>(engine, std::forward<Function>(func));
   }
 
   template <typename Function>
   function<bool(LuaValue, LuaValue)> wrapTableIterator(LuaEngine& engine, Function&& func) {
     return wrapTableIteratorArgs<typename FunctionTraits<Function>::Return>(
-        engine, forward<Function>(func), typename FunctionTraits<Function>::Args());
+        engine, std::forward<Function>(func), typename FunctionTraits<Function>::Args());
   }
 
   // Like lua_setfield / lua_getfield but raw.
@@ -1520,7 +1520,7 @@ LuaVariadic<typename std::decay<Container>::type::value_type> luaUnpack(Containe
   LuaVariadic<typename std::decay<Container>::type::value_type> ret;
   if (std::is_rvalue_reference<Container&&>::value) {
     for (auto& e : c)
-      ret.append(move(e));
+      ret.append(std::move(e));
   } else {
     for (auto const& e : c)
       ret.append(e);
@@ -1535,7 +1535,7 @@ LuaTupleReturn<Types...>::LuaTupleReturn(Types const&... args)
 template <typename... Types>
 template <typename... UTypes>
 LuaTupleReturn<Types...>::LuaTupleReturn(UTypes&&... args)
-  : Base(move(args)...) {}
+  : Base(std::move(args)...) {}
 
 template <typename... Types>
 template <typename... UTypes>
@@ -1548,7 +1548,7 @@ LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn const& rhs)
 
 template <typename... Types>
 LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn&& rhs)
-  : Base(move(rhs)) {}
+  : Base(std::move(rhs)) {}
 
 template <typename... Types>
 template <typename... UTypes>
@@ -1558,7 +1558,7 @@ LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn<UTypes...> const& rhs)
 template <typename... Types>
 template <typename... UTypes>
 LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn<UTypes...>&& rhs)
-  : Base(move(rhs)) {}
+  : Base(std::move(rhs)) {}
 
 template <typename... Types>
 LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn const& rhs) {
@@ -1568,7 +1568,7 @@ LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn con
 
 template <typename... Types>
 LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn&& rhs) {
-  Base::operator=(move(rhs));
+  Base::operator=(std::move(rhs));
   return *this;
 }
 
@@ -1582,7 +1582,7 @@ LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn<UTy
 template <typename... Types>
 template <typename... UTypes>
 LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn<UTypes...>&& rhs) {
-  Base::operator=((tuple<UTypes...> && )move(rhs));
+  Base::operator=((tuple<UTypes...> && )std::move(rhs));
   return *this;
 }
 
@@ -1593,10 +1593,10 @@ LuaTupleReturn<Types&...> luaTie(Types&... args) {
 
 template <typename... Types>
 LuaTupleReturn<typename std::decay<Types>::type...> luaTupleReturn(Types&&... args) {
-  return LuaTupleReturn<typename std::decay<Types>::type...>(forward<Types>(args)...);
+  return LuaTupleReturn<typename std::decay<Types>::type...>(std::forward<Types>(args)...);
 }
 
-inline LuaReference::LuaReference(LuaDetail::LuaHandle handle) : m_handle(move(handle)) {}
+inline LuaReference::LuaReference(LuaDetail::LuaHandle handle) : m_handle(std::move(handle)) {}
 
 inline bool LuaReference::operator==(LuaReference const& rhs) const {
   return tie(m_handle.engine, m_handle.handleIndex) == tie(rhs.m_handle.engine, rhs.m_handle.handleIndex);
@@ -1688,7 +1688,7 @@ inline bool operator!=(String const& s1, LuaString const& s2) {
 
 template <typename T, typename K>
 T LuaTable::get(K key) const {
-  return engine().luaTo<T>(engine().tableGet(false, handleIndex(), engine().luaFrom(move(key))));
+  return engine().luaTo<T>(engine().tableGet(false, handleIndex(), engine().luaFrom(std::move(key))));
 }
 
 template <typename T>
@@ -1698,17 +1698,17 @@ T LuaTable::get(char const* key) const {
 
 template <typename T, typename K>
 void LuaTable::set(K key, T value) const {
-  engine().tableSet(false, handleIndex(), engine().luaFrom(move(key)), engine().luaFrom(move(value)));
+  engine().tableSet(false, handleIndex(), engine().luaFrom(std::move(key)), engine().luaFrom(std::move(value)));
 }
 
 template <typename T>
 void LuaTable::set(char const* key, T value) const {
-  engine().tableSet(false, handleIndex(), key, engine().luaFrom(move(value)));
+  engine().tableSet(false, handleIndex(), key, engine().luaFrom(std::move(value)));
 }
 
 template <typename K>
 bool LuaTable::contains(K key) const {
-  return engine().tableGet(false, handleIndex(), engine().luaFrom(move(key))) != LuaNil;
+  return engine().tableGet(false, handleIndex(), engine().luaFrom(std::move(key))) != LuaNil;
 }
 
 template <typename K>
@@ -1718,12 +1718,12 @@ void LuaTable::remove(K key) const {
 
 template <typename Function>
 void LuaTable::iterate(Function&& function) const {
-  return engine().tableIterate(handleIndex(), LuaDetail::wrapTableIterator(engine(), forward<Function>(function)));
+  return engine().tableIterate(handleIndex(), LuaDetail::wrapTableIterator(engine(), std::forward<Function>(function)));
 }
 
 template <typename Return, typename... Args, typename Function>
 void LuaTable::iterateWithSignature(Function&& func) const {
-  return engine().tableIterate(handleIndex(), LuaDetail::wrapTableIteratorWithSignature<Return, Args...>(engine(), forward<Function>(func)));
+  return engine().tableIterate(handleIndex(), LuaDetail::wrapTableIteratorWithSignature<Return, Args...>(engine(), std::forward<Function>(func)));
 }
 
 template <typename T, typename K>
@@ -1779,27 +1779,27 @@ T& LuaUserData::get() const {
 
 template <typename Function>
 void LuaCallbacks::registerCallback(String name, Function&& func) {
-  if (!m_callbacks.insert(name, LuaDetail::wrapFunction(forward<Function>(func))).second)
+  if (!m_callbacks.insert(name, LuaDetail::wrapFunction(std::forward<Function>(func))).second)
     throw LuaException::format("Lua callback '{}' was registered twice", name);
 }
 
 template <typename Return, typename... Args, typename Function>
 void LuaCallbacks::registerCallbackWithSignature(String name, Function&& func) {
-  if (!m_callbacks.insert(name, LuaDetail::wrapFunctionWithSignature<Return, Args...>(forward<Function>(func))).second)
+  if (!m_callbacks.insert(name, LuaDetail::wrapFunctionWithSignature<Return, Args...>(std::forward<Function>(func))).second)
     throw LuaException::format("Lua callback '{}' was registered twice", name);
 }
 
 template <typename T>
 template <typename Function>
 void LuaMethods<T>::registerMethod(String name, Function&& func) {
-  if (!m_methods.insert(name, LuaDetail::wrapMethod(forward<Function>(move(func)))).second)
+  if (!m_methods.insert(name, LuaDetail::wrapMethod(std::forward<Function>(std::move(func)))).second)
     throw LuaException::format("Lua method '{}' was registered twice", name);
 }
 
 template <typename T>
 template <typename Return, typename... Args, typename Function>
 void LuaMethods<T>::registerMethodWithSignature(String name, Function&& func) {
-  if (!m_methods.insert(name, LuaDetail::wrapMethodWithSignature<Return, Args...>(forward<Function>(move(func))))
+  if (!m_methods.insert(name, LuaDetail::wrapMethodWithSignature<Return, Args...>(std::forward<Function>(std::move(func))))
            .second)
     throw LuaException::format("Lua method '{}' was registered twice", name);
 }
@@ -1811,12 +1811,12 @@ StringMap<LuaDetail::LuaWrappedFunction> const& LuaMethods<T>::methods() const {
 
 template <typename T>
 T LuaContext::getPath(String path) const {
-  return engine().luaTo<T>(engine().contextGetPath(handleIndex(), move(path)));
+  return engine().luaTo<T>(engine().contextGetPath(handleIndex(), std::move(path)));
 }
 
 template <typename T>
 void LuaContext::setPath(String key, T value) {
-  engine().contextSetPath(handleIndex(), move(key), engine().luaFrom<T>(move(value)));
+  engine().contextSetPath(handleIndex(), std::move(key), engine().luaFrom<T>(std::move(value)));
 }
 
 template <typename Ret>
@@ -1834,7 +1834,7 @@ Ret LuaContext::invokePath(String const& key, Args const&... args) const {
 
 template <typename T>
 LuaValue LuaContext::luaFrom(T&& t) {
-  return engine().luaFrom(forward<T>(t));
+  return engine().luaFrom(std::forward<T>(t));
 }
 
 template <typename T>
@@ -1844,7 +1844,7 @@ LuaValue LuaContext::luaFrom(T const& t) {
 
 template <typename T>
 Maybe<T> LuaContext::luaMaybeTo(LuaValue&& v) {
-  return engine().luaFrom(move(v));
+  return engine().luaFrom(std::move(v));
 }
 
 template <typename T>
@@ -1854,7 +1854,7 @@ Maybe<T> LuaContext::luaMaybeTo(LuaValue const& v) {
 
 template <typename T>
 T LuaContext::luaTo(LuaValue&& v) {
-  return engine().luaTo<T>(move(v));
+  return engine().luaTo<T>(std::move(v));
 }
 
 template <typename T>
@@ -1874,17 +1874,17 @@ LuaTable LuaContext::createArrayTable(Container const& array) {
 
 template <typename Function>
 LuaFunction LuaContext::createFunction(Function&& func) {
-  return engine().createFunction(forward<Function>(func));
+  return engine().createFunction(std::forward<Function>(func));
 }
 
 template <typename Return, typename... Args, typename Function>
 LuaFunction LuaContext::createFunctionWithSignature(Function&& func) {
-  return engine().createFunctionWithSignature<Return, Args...>(forward<Function>(func));
+  return engine().createFunctionWithSignature<Return, Args...>(std::forward<Function>(func));
 }
 
 template <typename T>
 LuaUserData LuaContext::createUserData(T t) {
-  return engine().createUserData(move(t));
+  return engine().createUserData(std::move(t));
 }
 
 template <typename T>
@@ -1894,7 +1894,7 @@ LuaMethods<T> LuaUserDataMethods<T>::make() {
 
 template <typename T>
 LuaValue LuaUserDataConverter<T>::from(LuaEngine& engine, T t) {
-  return engine.createUserData(move(t));
+  return engine.createUserData(std::move(t));
 }
 
 template <typename T>
@@ -1908,7 +1908,7 @@ Maybe<T> LuaUserDataConverter<T>::to(LuaEngine&, LuaValue const& v) {
 
 template <typename T>
 LuaValue LuaEngine::luaFrom(T&& t) {
-  return LuaConverter<typename std::decay<T>::type>::from(*this, forward<T>(t));
+  return LuaConverter<typename std::decay<T>::type>::from(*this, std::forward<T>(t));
 }
 
 template <typename T>
@@ -1918,7 +1918,7 @@ LuaValue LuaEngine::luaFrom(T const& t) {
 
 template <typename T>
 Maybe<T> LuaEngine::luaMaybeTo(LuaValue&& v) {
-  return LuaConverter<T>::to(*this, move(v));
+  return LuaConverter<T>::to(*this, std::move(v));
 }
 
 template <typename T>
@@ -1928,7 +1928,7 @@ Maybe<T> LuaEngine::luaMaybeTo(LuaValue const& v) {
 
 template <typename T>
 T LuaEngine::luaTo(LuaValue&& v) {
-  if (auto res = luaMaybeTo<T>(move(v)))
+  if (auto res = luaMaybeTo<T>(std::move(v)))
     return res.take();
   throw LuaConversionException::format("Error converting LuaValue to type '{}'", typeid(T).name());
 }
@@ -1961,12 +1961,12 @@ LuaTable LuaEngine::createArrayTable(Container const& array) {
 
 template <typename Function>
 LuaFunction LuaEngine::createFunction(Function&& func) {
-  return createWrappedFunction(LuaDetail::wrapFunction(forward<Function>(func)));
+  return createWrappedFunction(LuaDetail::wrapFunction(std::forward<Function>(func)));
 }
 
 template <typename Return, typename... Args, typename Function>
 LuaFunction LuaEngine::createFunctionWithSignature(Function&& func) {
-  return createWrappedFunction(LuaDetail::wrapFunctionWithSignature<Return, Args...>(forward<Function>(func)));
+  return createWrappedFunction(LuaDetail::wrapFunctionWithSignature<Return, Args...>(std::forward<Function>(func)));
 }
 
 template <typename... Args>
@@ -2026,7 +2026,7 @@ Maybe<LuaDetail::LuaFunctionReturn> LuaEngine::resumeThread(int handleIndex, Arg
     LuaVariadic<LuaValue> ret(returnValues);
     for (int i = returnValues - 1; i >= 0; --i)
       ret[i] = popLuaValue(threadState);
-    return LuaDetail::LuaFunctionReturn(move(ret));
+    return LuaDetail::LuaFunctionReturn(std::move(ret));
   }
 }
 
@@ -2071,7 +2071,7 @@ LuaUserData LuaEngine::createUserData(T t) {
 
   lua_checkstack(m_state, 2);
 
-  new (lua_newuserdata(m_state, sizeof(T))) T(move(t));
+  new (lua_newuserdata(m_state, sizeof(T))) T(std::move(t));
 
   lua_rawgeti(m_state, LUA_REGISTRYINDEX, typeMetatable);
   lua_setmetatable(m_state, -2);
@@ -2083,7 +2083,7 @@ template <typename T, typename K>
 T LuaEngine::getGlobal(K key) {
   lua_checkstack(m_state, 1);
   lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_scriptDefaultEnvRegistryId);
-  pushLuaValue(m_state, luaFrom(move(key)));
+  pushLuaValue(m_state, luaFrom(std::move(key)));
   lua_rawget(m_state, -2);
 
   LuaValue v = popLuaValue(m_state);
@@ -2109,8 +2109,8 @@ void LuaEngine::setGlobal(K key, T value) {
   lua_checkstack(m_state, 1);
 
   lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_scriptDefaultEnvRegistryId);
-  pushLuaValue(m_state, luaFrom(move(key)));
-  pushLuaValue(m_state, luaFrom(move(value)));
+  pushLuaValue(m_state, luaFrom(std::move(key)));
+  pushLuaValue(m_state, luaFrom(std::move(value)));
 
   lua_rawset(m_state, -3);
   lua_pop(m_state, 1);
diff --git a/source/core/StarLuaConverters.hpp b/source/core/StarLuaConverters.hpp
index f476d2e..277f691 100644
--- a/source/core/StarLuaConverters.hpp
+++ b/source/core/StarLuaConverters.hpp
@@ -33,8 +33,8 @@ template <typename T1, typename T2>
 struct LuaConverter<pair<T1, T2>> {
   static LuaValue from(LuaEngine& engine, pair<T1, T2>&& v) {
     auto t = engine.createTable();
-    t.set(1, move(v.first));
-    t.set(2, move(v.second));
+    t.set(1, std::move(v.first));
+    t.set(2, std::move(v.second));
     return t;
   }
 
@@ -46,7 +46,7 @@ struct LuaConverter<pair<T1, T2>> {
   }
 
   static Maybe<pair<T1, T2>> to(LuaEngine& engine, LuaValue const& v) {
-    if (auto table = engine.luaMaybeTo<LuaTable>(move(v))) {
+    if (auto table = engine.luaMaybeTo<LuaTable>(std::move(v))) {
       auto p1 = engine.luaMaybeTo<T1>(table->get(1));
       auto p2 = engine.luaMaybeTo<T2>(table->get(2));
       if (p1 && p2)
@@ -173,7 +173,7 @@ struct LuaConverter<Variant<FirstType, RestTypes...>> {
   }
 
   static LuaValue from(LuaEngine& engine, Variant<FirstType, RestTypes...>&& variant) {
-    return variant.call([&engine](auto& a) { return luaFrom(engine, move(a)); });
+    return variant.call([&engine](auto& a) { return luaFrom(engine, std::move(a)); });
   }
 
   static Maybe<Variant<FirstType, RestTypes...>> to(LuaEngine& engine, LuaValue const& v) {
@@ -194,7 +194,7 @@ struct LuaConverter<Variant<FirstType, RestTypes...>> {
   }
 
   static Maybe<Variant<FirstType, RestTypes...>> to(LuaEngine& engine, LuaValue&& v) {
-    return checkTypeTo<FirstType, RestTypes...>(engine, move(v));
+    return checkTypeTo<FirstType, RestTypes...>(engine, std::move(v));
   }
 
   template <typename CheckType1, typename CheckType2, typename... CheckTypeRest>
@@ -202,12 +202,12 @@ struct LuaConverter<Variant<FirstType, RestTypes...>> {
     if (auto t1 = engine.luaMaybeTo<CheckType1>(v))
       return t1;
     else
-      return checkTypeTo<CheckType2, CheckTypeRest...>(engine, move(v));
+      return checkTypeTo<CheckType2, CheckTypeRest...>(engine, std::move(v));
   }
 
   template <typename Type>
   static Maybe<Variant<FirstType, RestTypes...>> checkTypeTo(LuaEngine& engine, LuaValue&& v) {
-    return engine.luaMaybeTo<Type>(move(v));
+    return engine.luaMaybeTo<Type>(std::move(v));
   }
 };
 
@@ -226,7 +226,7 @@ struct LuaConverter<MVariant<Types...>> {
   static LuaValue from(LuaEngine& engine, MVariant<Types...>&& variant) {
     LuaValue value;
     variant.call([&value, &engine](auto& a) {
-        value = luaFrom(engine, move(a));
+        value = luaFrom(engine, std::move(a));
       });
     return value;
   }
@@ -253,7 +253,7 @@ struct LuaConverter<MVariant<Types...>> {
   static Maybe<MVariant<Types...>> to(LuaEngine& engine, LuaValue&& v) {
     if (v == LuaNil)
       return MVariant<Types...>();
-    return checkTypeTo<Types...>(engine, move(v));
+    return checkTypeTo<Types...>(engine, std::move(v));
   }
 
   template <typename CheckType1, typename CheckType2, typename... CheckTypeRest>
@@ -261,12 +261,12 @@ struct LuaConverter<MVariant<Types...>> {
     if (auto t1 = engine.luaMaybeTo<CheckType1>(v))
       return t1;
     else
-      return checkTypeTo<CheckType2, CheckTypeRest...>(engine, move(v));
+      return checkTypeTo<CheckType2, CheckTypeRest...>(engine, std::move(v));
   }
 
   template <typename CheckType>
   static Maybe<MVariant<Types...>> checkTypeTo(LuaEngine& engine, LuaValue&& v) {
-    return engine.luaMaybeTo<CheckType>(move(v));
+    return engine.luaMaybeTo<CheckType>(std::move(v));
   }
 
 };
diff --git a/source/core/StarMap.hpp b/source/core/StarMap.hpp
index cf9c260..187f4cf 100644
--- a/source/core/StarMap.hpp
+++ b/source/core/StarMap.hpp
@@ -172,7 +172,7 @@ auto MapMixin<BaseMap>::maybeTake(key_type const& k) -> Maybe<mapped_type> {
   if (i != Base::end()) {
     mapped_type v = std::move(i->second);
     Base::erase(i);
-    return move(v);
+    return v;
   }
 
   return {};
@@ -198,7 +198,7 @@ template <typename BaseMap>
 auto MapMixin<BaseMap>::value(key_type const& k, mapped_type d) const -> mapped_type {
   const_iterator i = Base::find(k);
   if (i == Base::end())
-    return std::move(d);
+    return d;
   else
     return i->second;
 }
@@ -260,12 +260,12 @@ auto MapMixin<BaseMap>::hasValue(mapped_type const& v) const -> bool {
 
 template <typename BaseMap>
 auto MapMixin<BaseMap>::insert(key_type k, mapped_type v) -> pair<iterator, bool> {
-  return Base::insert(value_type(move(k), move(v)));
+  return Base::insert(value_type(std::move(k), std::move(v)));
 }
 
 template <typename BaseMap>
 auto MapMixin<BaseMap>::add(key_type k, mapped_type v) -> mapped_type& {
-  auto pair = Base::insert(value_type(move(k), move(v)));
+  auto pair = Base::insert(value_type(std::move(k), std::move(v)));
   if (!pair.second)
     throw MapException(strf("Entry with key '{}' already present.", outputAny(k)));
   else
@@ -276,10 +276,10 @@ template <typename BaseMap>
 auto MapMixin<BaseMap>::set(key_type k, mapped_type v) -> mapped_type& {
   auto i = Base::find(k);
   if (i != Base::end()) {
-    i->second = move(v);
+    i->second = std::move(v);
     return i->second;
   } else {
-    return Base::insert(value_type(move(k), move(v))).first->second;
+    return Base::insert(value_type(std::move(k), std::move(v))).first->second;
   }
 }
 
diff --git a/source/core/StarMaybe.hpp b/source/core/StarMaybe.hpp
index 2b2b70d..2c53bcb 100644
--- a/source/core/StarMaybe.hpp
+++ b/source/core/StarMaybe.hpp
@@ -118,7 +118,7 @@ Maybe<T>::Maybe(T const& t)
 template <typename T>
 Maybe<T>::Maybe(T&& t)
   : Maybe() {
-  new (&m_data) T(forward<T>(t));
+  new (&m_data) T(std::forward<T>(t));
   m_initialized = true;
 }
 
@@ -135,7 +135,7 @@ template <typename T>
 Maybe<T>::Maybe(Maybe&& rhs)
   : Maybe() {
   if (rhs.m_initialized) {
-    new (&m_data) T(move(rhs.m_data));
+    new (&m_data) T(std::move(rhs.m_data));
     m_initialized = true;
     rhs.reset();
   }
@@ -308,7 +308,7 @@ T Maybe<T>::take() {
   if (!m_initialized)
     throw InvalidMaybeAccessException();
 
-  T val(move(m_data));
+  T val(std::move(m_data));
 
   reset();
 
@@ -318,7 +318,7 @@ T Maybe<T>::take() {
 template <typename T>
 bool Maybe<T>::put(T& t) {
   if (m_initialized) {
-    t = move(m_data);
+    t = std::move(m_data);
 
     reset();
 
@@ -335,7 +335,7 @@ void Maybe<T>::set(T const& t) {
 
 template <typename T>
 void Maybe<T>::set(T&& t) {
-  emplace(forward<T>(t));
+  emplace(std::forward<T>(t));
 }
 
 template <typename T>
@@ -343,7 +343,7 @@ template <typename... Args>
 void Maybe<T>::emplace(Args&&... t) {
   reset();
 
-  new (&m_data) T(forward<Args>(t)...);
+  new (&m_data) T(std::forward<Args>(t)...);
   m_initialized = true;
 }
 
diff --git a/source/core/StarMultiArray.hpp b/source/core/StarMultiArray.hpp
index 3668c8a..bb33490 100644
--- a/source/core/StarMultiArray.hpp
+++ b/source/core/StarMultiArray.hpp
@@ -326,14 +326,14 @@ void MultiArray<Element, Rank>::set(IndexArray const& index, Element element) {
       throw MultiArrayException(strf("Out of bounds on MultiArray::set({})", index));
   }
 
-  m_data[storageIndex(index)] = move(element);
+  m_data[storageIndex(index)] = std::move(element);
 }
 
 template <typename Element, size_t Rank>
 Element MultiArray<Element, Rank>::get(IndexArray const& index, Element def) {
   for (size_t i = Rank; i != 0; --i) {
     if (index[i - 1] >= m_shape[i - 1])
-      return move(def);
+      return std::move(def);
   }
 
   return m_data[storageIndex(index)];
@@ -346,7 +346,7 @@ void MultiArray<Element, Rank>::setResize(IndexArray const& index, Element eleme
     newShape[i] = std::max(m_shape[i], index[i] + 1);
   resize(newShape);
 
-  m_data[storageIndex(index)] = move(element);
+  m_data[storageIndex(index)] = std::move(element);
 }
 
 template <typename Element, size_t Rank>
@@ -369,26 +369,26 @@ template <typename Element, size_t Rank>
 template <typename OpType>
 void MultiArray<Element, Rank>::forEach(IndexArray const& min, SizeArray const& size, OpType&& op) {
   IndexArray index;
-  subForEach(min, size, forward<OpType>(op), index, 0, 0);
+  subForEach(min, size, std::forward<OpType>(op), index, 0, 0);
 }
 
 template <typename Element, size_t Rank>
 template <typename OpType>
 void MultiArray<Element, Rank>::forEach(IndexArray const& min, SizeArray const& size, OpType&& op) const {
   IndexArray index;
-  subForEach(min, size, forward<OpType>(op), index, 0, 0);
+  subForEach(min, size, std::forward<OpType>(op), index, 0, 0);
 }
 
 template <typename Element, size_t Rank>
 template <typename OpType>
 void MultiArray<Element, Rank>::forEach(OpType&& op) {
-  forEach(IndexArray::filled(0), size(), forward<OpType>(op));
+  forEach(IndexArray::filled(0), size(), std::forward<OpType>(op));
 }
 
 template <typename Element, size_t Rank>
 template <typename OpType>
 void MultiArray<Element, Rank>::forEach(OpType&& op) const {
-  forEach(IndexArray::filled(0), size(), forward<OpType>(op));
+  forEach(IndexArray::filled(0), size(), std::forward<OpType>(op));
 }
 
 template <typename Element, size_t Rank>
@@ -461,7 +461,7 @@ void MultiArray<Element, Rank>::subForEach(IndexArray const& min, SizeArray cons
     if (dim == Rank - 1)
       op(index, m_data[offset + i]);
     else
-      subForEach(min, size, forward<OpType>(op), index, (offset + i) * m_shape[dim + 1], dim + 1);
+      subForEach(min, size, std::forward<OpType>(op), index, (offset + i) * m_shape[dim + 1], dim + 1);
   }
 }
 
@@ -475,7 +475,7 @@ void MultiArray<Element, Rank>::subForEach(IndexArray const& min, SizeArray cons
     if (dim == Rank - 1)
       op(index, m_data[offset + i]);
     else
-      subForEach(min, size, forward<OpType>(op), index, (offset + i) * m_shape[dim + 1], dim + 1);
+      subForEach(min, size, std::forward<OpType>(op), index, (offset + i) * m_shape[dim + 1], dim + 1);
   }
 }
 
diff --git a/source/core/StarNetElementBasicFields.hpp b/source/core/StarNetElementBasicFields.hpp
index f0939a7..2d9f8e5 100644
--- a/source/core/StarNetElementBasicFields.hpp
+++ b/source/core/StarNetElementBasicFields.hpp
@@ -155,7 +155,7 @@ void NetElementBasicField<T>::set(T const& value) {
 
 template <typename T>
 void NetElementBasicField<T>::push(T value) {
-  m_value = move(value);
+  m_value = std::move(value);
   updated();
   m_latestUpdateVersion = m_netVersion ? m_netVersion->current() : 0;
   if (m_pendingInterpolatedValues)
@@ -251,14 +251,14 @@ void NetElementBasicField<T>::readNetDelta(DataStream& ds, float interpolationTi
     // case, this is an error or the step tracking is wildly off, so just clear
     // any other incoming values.
     if (interpolationTime > 0.0f && (m_pendingInterpolatedValues->empty() || interpolationTime >= m_pendingInterpolatedValues->last().first)) {
-      m_pendingInterpolatedValues->append({interpolationTime, move(t)});
+      m_pendingInterpolatedValues->append({interpolationTime, std::move(t)});
     } else {
-      m_value = move(t);
+      m_value = std::move(t);
       m_pendingInterpolatedValues->clear();
       updated();
     }
   } else {
-    m_value = move(t);
+    m_value = std::move(t);
     updated();
   }
 }
@@ -314,7 +314,7 @@ NetElementData<T>::NetElementData()
 
 template <typename T>
 NetElementData<T>::NetElementData(function<void(DataStream&, T&)> reader, function<void(DataStream&, T const&)> writer)
-  : m_reader(move(reader)), m_writer(move(writer)) {}
+  : m_reader(std::move(reader)), m_writer(std::move(writer)) {}
 
 template <typename T>
 void NetElementData<T>::readData(DataStream& ds, T& v) const {
diff --git a/source/core/StarNetElementContainers.hpp b/source/core/StarNetElementContainers.hpp
index 2127076..b48755d 100644
--- a/source/core/StarNetElementContainers.hpp
+++ b/source/core/StarNetElementContainers.hpp
@@ -124,7 +124,7 @@ void NetElementMapWrapper<BaseMap>::initNetVersion(NetElementVersion const* vers
   m_changeDataLastVersion = 0;
 
   for (auto& change : Star::take(m_pendingChangeData))
-    applyChange(move(change.second));
+    applyChange(std::move(change.second));
 
   addChangeData(ClearChange());
   for (auto const& p : *this)
@@ -140,7 +140,7 @@ template <typename BaseMap>
 void NetElementMapWrapper<BaseMap>::disableNetInterpolation() {
   m_interpolationEnabled = false;
   for (auto& change : Star::take(m_pendingChangeData))
-    applyChange(move(change.second));
+    applyChange(std::move(change.second));
 }
 
 template <typename BaseMap>
@@ -175,7 +175,7 @@ void NetElementMapWrapper<BaseMap>::netLoad(DataStream& ds) {
   for (uint64_t i = 0; i < count; ++i) {
     auto change = readChange(ds);
     addChangeData(change);
-    applyChange(move(change));
+    applyChange(std::move(change));
   }
 
   m_updated = true;
@@ -219,9 +219,9 @@ void NetElementMapWrapper<BaseMap>::readNetDelta(DataStream& ds, float interpola
       addChangeData(change);
 
       if (m_interpolationEnabled && interpolationTime > 0.0f)
-        addPendingChangeData(move(change), interpolationTime);
+        addPendingChangeData(std::move(change), interpolationTime);
       else
-        applyChange(move(change));
+        applyChange(std::move(change));
     } else {
       throw IOException("Improper delta code received in NetElementMapWrapper::readNetDelta");
     }
@@ -252,7 +252,7 @@ template <typename BaseMap>
 auto NetElementMapWrapper<BaseMap>::insert(value_type v) -> pair<const_iterator, bool> {
   auto res = BaseMap::insert(v);
   if (res.second) {
-    addChangeData(SetChange{move(v.first), move(v.second)});
+    addChangeData(SetChange{std::move(v.first), std::move(v.second)});
     m_updated = true;
   }
   return res;
@@ -260,12 +260,12 @@ auto NetElementMapWrapper<BaseMap>::insert(value_type v) -> pair<const_iterator,
 
 template <typename BaseMap>
 auto NetElementMapWrapper<BaseMap>::insert(key_type k, mapped_type v) -> pair<const_iterator, bool> {
-  return insert(value_type(move(k), move(v)));
+  return insert(value_type(std::move(k), std::move(v)));
 }
 
 template <typename BaseMap>
 void NetElementMapWrapper<BaseMap>::add(key_type k, mapped_type v) {
-  if (!insert(value_type(move(k), move(v))).second)
+  if (!insert(value_type(std::move(k), std::move(v))).second)
     throw MapException::format("Entry with key '{}' already present.", outputAny(k));
 }
 
@@ -274,13 +274,13 @@ void NetElementMapWrapper<BaseMap>::set(key_type k, mapped_type v) {
   auto i = BaseMap::find(k);
   if (i != BaseMap::end()) {
     if (!(i->second == v)) {
-      addChangeData(SetChange{move(k), v});
-      i->second = move(v);
+      addChangeData(SetChange{std::move(k), v});
+      i->second = std::move(v);
       m_updated = true;
     }
   } else {
     addChangeData(SetChange{k, v});
-    BaseMap::insert(value_type(move(k), move(v)));
+    BaseMap::insert(value_type(std::move(k), std::move(v)));
     m_updated = true;
   }
 }
@@ -289,11 +289,11 @@ template <typename BaseMap>
 void NetElementMapWrapper<BaseMap>::push(key_type k, mapped_type v) {
   auto i = BaseMap::find(k);
   if (i != BaseMap::end()) {
-    addChangeData(SetChange(move(k), v));
-    i->second = move(v);
+    addChangeData(SetChange(std::move(k), v));
+    i->second = std::move(v);
   } else {
     addChangeData(SetChange(k, v));
-    BaseMap::insert(value_type(move(k), move(v)));
+    BaseMap::insert(value_type(std::move(k), std::move(v)));
   }
   m_updated = true;
 }
@@ -322,7 +322,7 @@ auto NetElementMapWrapper<BaseMap>::take(key_type const& k) -> mapped_type {
   auto i = BaseMap::find(k);
   if (i == BaseMap::end())
     throw MapException::format("Key '{}' not found in Map::take()", outputAny(k));
-  auto m = move(i->second);
+  auto m = std::move(i->second);
   erase(i);
   return m;
 }
@@ -332,9 +332,9 @@ auto NetElementMapWrapper<BaseMap>::maybeTake(key_type const& k) -> Maybe<mapped
   auto i = BaseMap::find(k);
   if (i == BaseMap::end())
     return {};
-  auto m = move(i->second);
+  auto m = std::move(i->second);
   erase(i);
-  return Maybe<mapped_type>(move(m));
+  return Maybe<mapped_type>(std::move(m));
 }
 
 template <typename BaseMap>
@@ -368,7 +368,7 @@ void NetElementMapWrapper<BaseMap>::reset(BaseMap values) {
     }
   }
 
-  BaseMap::operator=(move(values));
+  BaseMap::operator=(std::move(values));
 }
 
 template <typename BaseMap>
@@ -420,7 +420,7 @@ void NetElementMapWrapper<BaseMap>::addChangeData(ElementChange change) {
   uint64_t currentVersion = m_netVersion ? m_netVersion->current() : 0;
   starAssert(m_changeData.empty() || m_changeData.last().first <= currentVersion);
 
-  m_changeData.append({currentVersion, move(change)});
+  m_changeData.append({currentVersion, std::move(change)});
 
   m_changeDataLastVersion = max<int64_t>((int64_t)currentVersion - MaxChangeDataVersions, 0);
   while (!m_changeData.empty() && m_changeData.first().first < m_changeDataLastVersion)
@@ -431,17 +431,17 @@ template <typename BaseMap>
 void NetElementMapWrapper<BaseMap>::addPendingChangeData(ElementChange change, float interpolationTime) {
   if (!m_pendingChangeData.empty() && interpolationTime < m_pendingChangeData.last().first) {
     for (auto& change : Star::take(m_pendingChangeData))
-      applyChange(move(change.second));
+      applyChange(std::move(change.second));
   }
-  m_pendingChangeData.append({interpolationTime, move(change)});
+  m_pendingChangeData.append({interpolationTime, std::move(change)});
 }
 
 template <typename BaseMap>
 void NetElementMapWrapper<BaseMap>::applyChange(ElementChange change) {
   if (auto set = change.template ptr<SetChange>())
-    BaseMap::set(move(set->key), move(set->value));
+    BaseMap::set(std::move(set->key), std::move(set->value));
   else if (auto remove = change.template ptr<RemoveChange>())
-    BaseMap::remove(move(remove->key));
+    BaseMap::remove(std::move(remove->key));
   else
     BaseMap::clear();
   m_updated = true;
diff --git a/source/core/StarNetElementDynamicGroup.hpp b/source/core/StarNetElementDynamicGroup.hpp
index 5d34c8d..75d11c8 100644
--- a/source/core/StarNetElementDynamicGroup.hpp
+++ b/source/core/StarNetElementDynamicGroup.hpp
@@ -91,7 +91,7 @@ auto NetElementDynamicGroup<Element>::addNetElement(ElementPtr element) -> Eleme
   readyElement(element);
   DataStreamBuffer storeBuffer;
   element->netStore(storeBuffer);
-  auto id = m_idMap.add(move(element));
+  auto id = m_idMap.add(std::move(element));
 
   addChangeData(ElementAddition(id, storeBuffer.takeData()));
 
@@ -192,7 +192,7 @@ void NetElementDynamicGroup<Element>::netLoad(DataStream& ds) {
     element->netLoad(storeBuffer);
     readyElement(element);
 
-    m_idMap.add(id, move(element));
+    m_idMap.add(id, std::move(element));
     addChangeData(ElementAddition(id, storeBuffer.takeData()));
   }
 }
@@ -256,10 +256,10 @@ void NetElementDynamicGroup<Element>::readNetDelta(DataStream& ds, float interpo
           m_idMap.clear();
         } else if (auto addition = changeUpdate.template ptr<ElementAddition>()) {
           ElementPtr element = make_shared<Element>();
-          DataStreamBuffer storeBuffer(move(get<1>(*addition)));
+          DataStreamBuffer storeBuffer(std::move(get<1>(*addition)));
           element->netLoad(storeBuffer);
           readyElement(element);
-          m_idMap.add(get<0>(*addition), move(element));
+          m_idMap.add(get<0>(*addition), std::move(element));
         } else if (auto removal = changeUpdate.template ptr<ElementRemoval>()) {
           m_idMap.remove(*removal);
         }
@@ -296,7 +296,7 @@ void NetElementDynamicGroup<Element>::addChangeData(ElementChange change) {
   uint64_t currentVersion = m_netVersion ? m_netVersion->current() : 0;
   starAssert(m_changeData.empty() || m_changeData.last().first <= currentVersion);
 
-  m_changeData.append({currentVersion, move(change)});
+  m_changeData.append({currentVersion, std::move(change)});
 
   m_changeDataLastVersion = max<int64_t>((int64_t)currentVersion - MaxChangeDataVersions, 0);
   while (!m_changeData.empty() && m_changeData.first().first < m_changeDataLastVersion)
diff --git a/source/core/StarNetElementFloatFields.hpp b/source/core/StarNetElementFloatFields.hpp
index 835b3ec..20895cd 100644
--- a/source/core/StarNetElementFloatFields.hpp
+++ b/source/core/StarNetElementFloatFields.hpp
@@ -92,7 +92,7 @@ void NetElementFloating<T>::setFixedPointBase(Maybe<T> fixedPointBase) {
 
 template <typename T>
 void NetElementFloating<T>::setInterpolator(function<T(T, T, T)> interpolator) {
-  m_interpolator = move(interpolator);
+  m_interpolator = std::move(interpolator);
 }
 
 template <typename T>
diff --git a/source/core/StarNetElementSignal.hpp b/source/core/StarNetElementSignal.hpp
index c1a89ac..03a2586 100644
--- a/source/core/StarNetElementSignal.hpp
+++ b/source/core/StarNetElementSignal.hpp
@@ -71,7 +71,7 @@ template <typename Signal>
 void NetElementSignal<Signal>::disableNetInterpolation() {
   m_netInterpolationEnabled = false;
   for (auto& p : take(m_pendingSignals))
-    send(move(p.second));
+    send(std::move(p.second));
 }
 
 template <typename Signal>
@@ -112,11 +112,11 @@ void NetElementSignal<Signal>::readNetDelta(DataStream& ds, float interpolationT
     if (m_netInterpolationEnabled && interpolationTime > 0.0f) {
       if (!m_pendingSignals.empty() && m_pendingSignals.last().first > interpolationTime) {
         for (auto& p : take(m_pendingSignals))
-          send(move(p.second));
+          send(std::move(p.second));
       }
-      m_pendingSignals.append({interpolationTime, move(s)});
+      m_pendingSignals.append({interpolationTime, std::move(s)});
     } else {
-      send(move(s));
+      send(std::move(s));
     }
   }
 }
diff --git a/source/core/StarNetElementSyncGroup.cpp b/source/core/StarNetElementSyncGroup.cpp
index 4ead00f..ac8da92 100644
--- a/source/core/StarNetElementSyncGroup.cpp
+++ b/source/core/StarNetElementSyncGroup.cpp
@@ -68,11 +68,11 @@ void NetElementSyncGroup::netElementsNeedLoad(bool) {}
 void NetElementSyncGroup::netElementsNeedStore() {}
 
 void NetElementCallbackGroup::setNeedsLoadCallback(function<void(bool)> needsLoadCallback) {
-  m_netElementsNeedLoad = move(needsLoadCallback);
+  m_netElementsNeedLoad = std::move(needsLoadCallback);
 }
 
 void NetElementCallbackGroup::setNeedsStoreCallback(function<void()> needsStoreCallback) {
-  m_netElementsNeedStore = move(needsStoreCallback);
+  m_netElementsNeedStore = std::move(needsStoreCallback);
 }
 
 void NetElementCallbackGroup::netElementsNeedLoad(bool load) {
diff --git a/source/core/StarNetElementTop.hpp b/source/core/StarNetElementTop.hpp
index fa85688..454b34f 100644
--- a/source/core/StarNetElementTop.hpp
+++ b/source/core/StarNetElementTop.hpp
@@ -68,7 +68,7 @@ void NetElementTop<BaseNetElement>::readNetState(ByteArray data, float interpola
     BaseNetElement::blankNetDelta(interpolationTime);
 
   } else {
-    DataStreamBuffer ds(move(data));
+    DataStreamBuffer ds(std::move(data));
 
     if (ds.read<bool>())
       BaseNetElement::netLoad(ds);
diff --git a/source/core/StarObserverStream.hpp b/source/core/StarObserverStream.hpp
index c97376c..61c4f91 100644
--- a/source/core/StarObserverStream.hpp
+++ b/source/core/StarObserverStream.hpp
@@ -61,7 +61,7 @@ void ObserverStream<T>::setHistoryLimit(uint64_t historyLimit) {
 
 template <typename T>
 void ObserverStream<T>::add(T value) {
-  m_values.append({m_nextStep, move(value)});
+  m_values.append({m_nextStep, std::move(value)});
   tick(1);
 }
 
diff --git a/source/core/StarOptionParser.cpp b/source/core/StarOptionParser.cpp
index f849f43..3cd32cc 100644
--- a/source/core/StarOptionParser.cpp
+++ b/source/core/StarOptionParser.cpp
@@ -4,29 +4,29 @@
 namespace Star {
 
 void OptionParser::setCommandName(String commandName) {
-  m_commandName = move(commandName);
+  m_commandName = std::move(commandName);
 }
 
 void OptionParser::setSummary(String summary) {
-  m_summary = move(summary);
+  m_summary = std::move(summary);
 }
 
 void OptionParser::setAdditionalHelp(String help) {
-  m_additionalHelp = move(help);
+  m_additionalHelp = std::move(help);
 }
 
 void OptionParser::addSwitch(String const& flag, String description) {
-  if (!m_options.insert(flag, Switch{flag, move(description)}).second)
+  if (!m_options.insert(flag, Switch{flag, std::move(description)}).second)
     throw OptionParserException::format("Duplicate switch '-{}' added", flag);
 }
 
 void OptionParser::addParameter(String const& flag, String argument, RequirementMode requirementMode, String description) {
-  if (!m_options.insert(flag, Parameter{flag, move(argument), requirementMode, move(description)}).second)
+  if (!m_options.insert(flag, Parameter{flag, std::move(argument), requirementMode, std::move(description)}).second)
     throw OptionParserException::format("Duplicate flag '-{}' added", flag);
 }
 
 void OptionParser::addArgument(String argument, RequirementMode requirementMode, String description) {
-  m_arguments.append(Argument{move(argument), requirementMode, move(description)});
+  m_arguments.append(Argument{std::move(argument), requirementMode, std::move(description)});
 }
 
 pair<OptionParser::Options, StringList> OptionParser::parseOptions(StringList const& arguments) const {
@@ -51,7 +51,7 @@ pair<OptionParser::Options, StringList> OptionParser::parseOptions(StringList co
       }
 
       if (option->is<Switch>()) {
-        result.switches.add(move(flag));
+        result.switches.add(std::move(flag));
       } else {
         auto const& parameter = option->get<Parameter>();
         if (!it.hasNext()) {
@@ -63,7 +63,7 @@ pair<OptionParser::Options, StringList> OptionParser::parseOptions(StringList co
           errors.append(strf("Option with argument '-{}' specified multiple times", flag));
           continue;
         }
-        result.parameters[move(flag)].append(move(val));
+        result.parameters[std::move(flag)].append(std::move(val));
       }
 
     } else {
@@ -96,7 +96,7 @@ pair<OptionParser::Options, StringList> OptionParser::parseOptions(StringList co
     errors.append(strf(
         "Too many positional arguments given, expected at most {} got {}", maximumArguments, result.arguments.size()));
 
-  return {move(result), move(errors)};
+  return {std::move(result), std::move(errors)};
 }
 
 void OptionParser::printHelp(std::ostream& os) const {
diff --git a/source/core/StarOrderedMap.hpp b/source/core/StarOrderedMap.hpp
index 4f2dc22..be99769 100644
--- a/source/core/StarOrderedMap.hpp
+++ b/source/core/StarOrderedMap.hpp
@@ -192,7 +192,7 @@ OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::OrderedMapWrapper(Inp
 template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
 OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::OrderedMapWrapper(initializer_list<value_type> list) {
   for (value_type v : list)
-    insert(move(v));
+    insert(std::move(v));
 }
 
 template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
@@ -242,7 +242,7 @@ template <template <typename...> class Map, typename Key, typename Value, typena
 auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::value(key_type const& k, mapped_type d) const -> mapped_type {
   auto i = m_map.find(k);
   if (i == m_map.end())
-    return move(d);
+    return d;
   else
     return i->second->second;
 }
@@ -335,7 +335,7 @@ auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insert(value_typ
 
 template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
 auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insert(key_type k, mapped_type v) -> pair<iterator, bool> {
-  return insert(value_type(move(k), move(v)));
+  return insert(value_type(std::move(k), std::move(v)));
 }
 
 template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
@@ -352,12 +352,12 @@ auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insertFront(valu
 
 template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
 auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insertFront(key_type k, mapped_type v) -> pair<iterator, bool> {
-  return insertFront(value_type(move(k), move(v)));
+  return insertFront(value_type(std::move(k), std::move(v)));
 }
 
 template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
 auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::add(key_type k, mapped_type v) -> mapped_type& {
-  auto pair = insert(value_type(move(k), move(v)));
+  auto pair = insert(value_type(std::move(k), std::move(v)));
   if (!pair.second)
     throw MapException(strf("Entry with key '{}' already present.", outputAny(k)));
   else
@@ -368,10 +368,10 @@ template <template <typename...> class Map, typename Key, typename Value, typena
 auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::set(key_type k, mapped_type v) -> mapped_type& {
   auto i = find(k);
   if (i != end()) {
-    i->second = move(v);
+    i->second = std::move(v);
     return i->second;
   } else {
-    return insert(value_type(move(k), move(v))).first->second;
+    return insert(value_type(std::move(k), std::move(v))).first->second;
   }
 }
 
@@ -575,11 +575,11 @@ template <template <typename...> class Map, typename Key, typename Value, typena
 auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insert(iterator pos, value_type v) -> iterator {
   auto i = m_map.find(v.first);
   if (i == m_map.end()) {
-    iterator orderIt = m_order.insert(pos, move(v));
+    iterator orderIt = m_order.insert(pos, std::move(v));
     m_map.insert(typename MapType::value_type(std::cref(orderIt->first), orderIt));
     return orderIt;
   } else {
-    i->second->second = move(v.second);
+    i->second->second = std::move(v.second);
     m_order.splice(pos, m_order, i->second);
     return i->second;
   }
diff --git a/source/core/StarOrderedSet.hpp b/source/core/StarOrderedSet.hpp
index 1f42132..abfb19b 100644
--- a/source/core/StarOrderedSet.hpp
+++ b/source/core/StarOrderedSet.hpp
@@ -167,7 +167,7 @@ template <template <typename...> class Map, typename Value, typename Allocator,
 auto OrderedSetWrapper<Map, Value, Allocator, Args...>::values() const -> List<value_type> {
   List<value_type> values;
   for (auto p : *this)
-    values.append(move(p));
+    values.append(std::move(p));
   return values;
 }
 
diff --git a/source/core/StarOutputProxy.hpp b/source/core/StarOutputProxy.hpp
index 6449d94..d8761fa 100644
--- a/source/core/StarOutputProxy.hpp
+++ b/source/core/StarOutputProxy.hpp
@@ -49,7 +49,7 @@ struct OutputProxy {
   typedef function<void(std::ostream&)> PrintFunction;
 
   OutputProxy(PrintFunction p)
-    : print(move(p)) {}
+    : print(std::move(p)) {}
 
   PrintFunction print;
 };
diff --git a/source/core/StarParametricFunction.hpp b/source/core/StarParametricFunction.hpp
index 8221c05..64bede2 100644
--- a/source/core/StarParametricFunction.hpp
+++ b/source/core/StarParametricFunction.hpp
@@ -125,8 +125,8 @@ ParametricTable<IndexType, ValueType>::ParametricTable(PairContainer indexValueP
       });
 
   for (auto const& pair : indexValuePairs) {
-    m_indexes.push_back(move(std::get<0>(pair)));
-    m_values.push_back(move(std::get<1>(pair)));
+    m_indexes.push_back(std::move(std::get<0>(pair)));
+    m_values.push_back(std::move(std::get<1>(pair)));
   }
 
   for (size_t i = 0; i < size() - 1; ++i) {
@@ -138,8 +138,8 @@ ParametricTable<IndexType, ValueType>::ParametricTable(PairContainer indexValueP
 template <typename IndexType, typename ValueType>
 size_t ParametricTable<IndexType, ValueType>::addPoint(IndexType index, ValueType value) {
   size_t insertLocation = std::distance(m_indexes.begin(), std::upper_bound(m_indexes.begin(), m_indexes.end(), index));
-  m_indexes.insert(m_indexes.begin() + insertLocation, move(index));
-  m_values.insert(m_values.begin() + insertLocation, move(value));
+  m_indexes.insert(m_indexes.begin() + insertLocation, std::move(index));
+  m_values.insert(m_values.begin() + insertLocation, std::move(value));
   return insertLocation;
 }
 
diff --git a/source/core/StarPerlin.hpp b/source/core/StarPerlin.hpp
index b042e47..294f80f 100644
--- a/source/core/StarPerlin.hpp
+++ b/source/core/StarPerlin.hpp
@@ -210,7 +210,7 @@ Perlin<Float>::Perlin(Perlin const& perlin) {
 
 template <typename Float>
 Perlin<Float>::Perlin(Perlin&& perlin) {
-  *this = move(perlin);
+  *this = std::move(perlin);
 }
 
 template <typename Float>
@@ -261,10 +261,10 @@ Perlin<Float>& Perlin<Float>::operator=(Perlin&& perlin) {
   m_offset = perlin.m_offset;
   m_gain = perlin.m_gain;
 
-  p = move(perlin.p);
-  g3 = move(perlin.g3);
-  g2 = move(perlin.g2);
-  g1 = move(perlin.g1);
+  p = std::move(perlin.p);
+  g3 = std::move(perlin.g3);
+  g2 = std::move(perlin.g2);
+  g1 = std::move(perlin.g1);
 
   return *this;
 }
diff --git a/source/core/StarPoly.hpp b/source/core/StarPoly.hpp
index 58cfca8..806b495 100644
--- a/source/core/StarPoly.hpp
+++ b/source/core/StarPoly.hpp
@@ -186,7 +186,7 @@ Polygon<DataType> Polygon<DataType>::convexHull(VertexList points) {
   upper.removeLast();
   lower.removeLast();
   lower.appendAll(take(upper));
-  return Polygon<DataType>(move(lower));
+  return Polygon<DataType>(std::move(lower));
 }
 
 template <typename DataType>
@@ -218,7 +218,7 @@ Polygon<DataType> Polygon<DataType>::clip(Polygon inputPoly, Polygon convexClipP
     }
   }
 
-  return Polygon(move(outputVertexes));
+  return Polygon(std::move(outputVertexes));
 }
 
 template <typename DataType>
@@ -230,7 +230,7 @@ Polygon<DataType>::Polygon(Polygon const& rhs)
 
 template <typename DataType>
 Polygon<DataType>::Polygon(Polygon&& rhs)
-  : m_vertexes(move(rhs.m_vertexes)) {}
+  : m_vertexes(std::move(rhs.m_vertexes)) {}
 
 template <typename DataType>
 template <typename DataType2>
@@ -303,7 +303,7 @@ void Polygon<DataType>::deduplicateVertexes(float maxDistance) {
   if (vmagSquared(newVertexes.first() - newVertexes.last()) <= distSquared)
     newVertexes.removeLast();
 
-  m_vertexes = move(newVertexes);
+  m_vertexes = std::move(newVertexes);
 }
 
 template <typename DataType>
@@ -426,7 +426,7 @@ Polygon<DataType>& Polygon<DataType>::operator=(Polygon const& rhs) {
 
 template <typename DataType>
 Polygon<DataType>& Polygon<DataType>::operator=(Polygon&& rhs) {
-  m_vertexes = move(rhs.m_vertexes);
+  m_vertexes = std::move(rhs.m_vertexes);
   return *this;
 }
 
diff --git a/source/core/StarPythonic.hpp b/source/core/StarPythonic.hpp
index 0bfdc50..0131130 100644
--- a/source/core/StarPythonic.hpp
+++ b/source/core/StarPythonic.hpp
@@ -599,7 +599,7 @@ template <typename ResultContainer, typename Iterable>
 ResultContainer enumerateConstruct(Iterable&& list) {
   ResultContainer res;
   for (auto el : enumerateIterator(list))
-    res.push_back(move(el));
+    res.push_back(std::move(el));
 
   return res;
 }
diff --git a/source/core/StarRefPtr.hpp b/source/core/StarRefPtr.hpp
index 906d4ff..8fabcdb 100644
--- a/source/core/StarRefPtr.hpp
+++ b/source/core/StarRefPtr.hpp
@@ -278,7 +278,7 @@ RefPtr<Type1 const> as(RefPtr<Type2 const> const& p) {
 
 template <typename T, typename... Args>
 RefPtr<T> make_ref(Args&&... args) {
-  return RefPtr<T>(new T(forward<Args>(args)...));
+  return RefPtr<T>(new T(std::forward<Args>(args)...));
 }
 
 template <typename T>
diff --git a/source/core/StarRpcPromise.hpp b/source/core/StarRpcPromise.hpp
index dcfd242..7a08750 100644
--- a/source/core/StarRpcPromise.hpp
+++ b/source/core/StarRpcPromise.hpp
@@ -70,17 +70,17 @@ private:
 
 template <typename Result, typename Error>
 void RpcPromiseKeeper<Result, Error>::fulfill(Result result) {
-  m_fulfill(move(result));
+  m_fulfill(std::move(result));
 }
 
 template <typename Result, typename Error>
 void RpcPromiseKeeper<Result, Error>::fail(Error error) {
-  m_fail(move(error));
+  m_fail(std::move(error));
 }
 
 template <typename Result, typename Error>
 pair<RpcPromise<Result, Error>, RpcPromiseKeeper<Result, Error>> RpcPromise<Result, Error>::createPair() {
-  auto valuePtr = make_shared<Value>();
+  auto valuePtr = std::make_shared<Value>();
 
   RpcPromise promise;
   promise.m_getValue = [valuePtr]() {
@@ -91,21 +91,21 @@ pair<RpcPromise<Result, Error>, RpcPromiseKeeper<Result, Error>> RpcPromise<Resu
   keeper.m_fulfill = [valuePtr](Result result) {
     if (valuePtr->result || valuePtr->error)
       throw RpcPromiseException("fulfill called on already finished RpcPromise");
-    valuePtr->result = move(result);
+    valuePtr->result = std::move(result);
   };
   keeper.m_fail = [valuePtr](Error error) {
     if (valuePtr->result || valuePtr->error)
       throw RpcPromiseException("fail called on already finished RpcPromise");
-    valuePtr->error = move(error);
+    valuePtr->error = std::move(error);
   };
 
-  return {move(promise), move(keeper)};
+  return {std::move(promise), std::move(keeper)};
 }
 
 template <typename Result, typename Error>
 RpcPromise<Result, Error> RpcPromise<Result, Error>::createFulfilled(Result result) {
-  auto valuePtr = make_shared<Value>();
-  valuePtr->result = move(result);
+  auto valuePtr = std::make_shared<Value>();
+  valuePtr->result = std::move(result);
 
   RpcPromise<Result, Error> promise;
   promise.m_getValue = [valuePtr]() {
@@ -116,8 +116,8 @@ RpcPromise<Result, Error> RpcPromise<Result, Error>::createFulfilled(Result resu
 
 template <typename Result, typename Error>
 RpcPromise<Result, Error> RpcPromise<Result, Error>::createFailed(Error error) {
-  auto valuePtr = make_shared<Value>();
-  valuePtr->error = move(error);
+  auto valuePtr = std::make_shared<Value>();
+  valuePtr->error = std::move(error);
 
   RpcPromise<Result, Error> promise;
   promise.m_getValue = [valuePtr]() {
@@ -157,7 +157,7 @@ template <typename Function>
 decltype(auto) RpcPromise<Result, Error>::wrap(Function function) {
   typedef RpcPromise<typename std::decay<decltype(function(std::declval<Result>()))>::type, Error> WrappedPromise;
   WrappedPromise wrappedPromise;
-  wrappedPromise.m_getValue = [wrapper = move(function), valuePtr = make_shared<typename WrappedPromise::Value>(), otherGetValue = m_getValue]() {
+  wrappedPromise.m_getValue = [wrapper = std::move(function), valuePtr = std::make_shared<typename WrappedPromise::Value>(), otherGetValue = m_getValue]() {
     if (!valuePtr->result && !valuePtr->error) {
       auto otherValue = otherGetValue();
       if (otherValue->result)
diff --git a/source/core/StarRpcThreadPromise.hpp b/source/core/StarRpcThreadPromise.hpp
index bae509c..043d0e7 100644
--- a/source/core/StarRpcThreadPromise.hpp
+++ b/source/core/StarRpcThreadPromise.hpp
@@ -66,12 +66,12 @@ private:
 
 template <typename Result, typename Error>
 void RpcThreadPromiseKeeper<Result, Error>::fulfill(Result result) {
-  m_fulfill(move(result));
+  m_fulfill(std::move(result));
 }
 
 template <typename Result, typename Error>
 void RpcThreadPromiseKeeper<Result, Error>::fail(Error error) {
-  m_fail(move(error));
+  m_fail(std::move(error));
 }
 
 template <typename Result, typename Error>
@@ -88,22 +88,22 @@ pair<RpcThreadPromise<Result, Error>, RpcThreadPromiseKeeper<Result, Error>> Rpc
     MutexLocker lock(valuePtr->mutex);
     if (valuePtr->result || valuePtr->error)
       throw RpcThreadPromiseException("fulfill called on already finished RpcThreadPromise");
-    valuePtr->result = move(result);
+    valuePtr->result = std::move(result);
   };
   keeper.m_fail = [valuePtr](Error error) {
     MutexLocker lock(valuePtr->mutex);
     if (valuePtr->result || valuePtr->error)
       throw RpcThreadPromiseException("fail called on already finished RpcThreadPromise");
-    valuePtr->error = move(error);
+    valuePtr->error = std::move(error);
   };
 
-  return {move(promise), move(keeper)};
+  return {std::move(promise), std::move(keeper)};
 }
 
 template <typename Result, typename Error>
 RpcThreadPromise<Result, Error> RpcThreadPromise<Result, Error>::createFulfilled(Result result) {
   auto valuePtr = make_shared<Value>();
-  valuePtr->result = move(result);
+  valuePtr->result = std::move(result);
 
   RpcThreadPromise<Result, Error> promise;
   promise.m_getValue = [valuePtr]() {
@@ -115,7 +115,7 @@ RpcThreadPromise<Result, Error> RpcThreadPromise<Result, Error>::createFulfilled
 template <typename Result, typename Error>
 RpcThreadPromise<Result, Error> RpcThreadPromise<Result, Error>::createFailed(Error error) {
   auto valuePtr = make_shared<Value>();
-  valuePtr->error = move(error);
+  valuePtr->error = std::move(error);
 
   RpcThreadPromise<Result, Error> promise;
   promise.m_getValue = [valuePtr]() {
diff --git a/source/core/StarSectorArray2D.hpp b/source/core/StarSectorArray2D.hpp
index 4645804..1dd88a1 100644
--- a/source/core/StarSectorArray2D.hpp
+++ b/source/core/StarSectorArray2D.hpp
@@ -213,7 +213,7 @@ auto SectorArray2D<ElementT, SectorSize>::sector(Sector const& id) const -> Arra
 template <typename ElementT, size_t SectorSize>
 void SectorArray2D<ElementT, SectorSize>::loadSector(Sector const& id, ArrayPtr array) {
   auto& data = m_sectors(id[0], id[1]);
-  data = move(array);
+  data = std::move(array);
   if (data)
     m_loadedSectors.add(id);
   else
@@ -224,7 +224,7 @@ template <typename ElementT, size_t SectorSize>
 typename SectorArray2D<ElementT, SectorSize>::ArrayPtr SectorArray2D<ElementT, SectorSize>::copySector(
     Sector const& id) {
   if (auto const& array = m_sectors(id))
-    return make_unique<Array>(*array);
+    return std::make_unique<Array>(*array);
   else
     return {};
 }
@@ -235,7 +235,7 @@ typename SectorArray2D<ElementT, SectorSize>::ArrayPtr SectorArray2D<ElementT, S
   ArrayPtr ret;
   m_loadedSectors.remove(id);
   std::swap(m_sectors(id[0], id[1]), ret);
-  return move(ret);
+  return ret;
 }
 
 template <typename ElementT, size_t SectorSize>
@@ -268,14 +268,14 @@ template <typename ElementT, size_t SectorSize>
 template <typename Function>
 bool SectorArray2D<ElementT, SectorSize>::eval(
     size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) const {
-  return const_cast<SectorArray2D*>(this)->evalPriv(minX, minY, width, height, forward<Function>(function), evalEmpty);
+  return const_cast<SectorArray2D*>(this)->evalPriv(minX, minY, width, height, std::forward<Function>(function), evalEmpty);
 }
 
 template <typename ElementT, size_t SectorSize>
 template <typename Function>
 bool SectorArray2D<ElementT, SectorSize>::eval(
     size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) {
-  return evalPriv(minX, minY, width, height, forward<Function>(function), evalEmpty);
+  return evalPriv(minX, minY, width, height, std::forward<Function>(function), evalEmpty);
 }
 
 template <typename ElementT, size_t SectorSize>
@@ -283,14 +283,14 @@ template <typename Function>
 bool SectorArray2D<ElementT, SectorSize>::evalColumns(
     size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) const {
   return const_cast<SectorArray2D*>(this)->evalColumnsPriv(
-      minX, minY, width, height, forward<Function>(function), evalEmpty);
+      minX, minY, width, height, std::forward<Function>(function), evalEmpty);
 }
 
 template <typename ElementT, size_t SectorSize>
 template <typename Function>
 bool SectorArray2D<ElementT, SectorSize>::evalColumns(
     size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) {
-  return evalColumnsPriv(minX, minY, width, height, forward<Function>(function), evalEmpty);
+  return evalColumnsPriv(minX, minY, width, height, std::forward<Function>(function), evalEmpty);
 }
 
 template <typename ElementT, size_t SectorSize>
diff --git a/source/core/StarSet.hpp b/source/core/StarSet.hpp
index 8950e9c..f32a46c 100644
--- a/source/core/StarSet.hpp
+++ b/source/core/StarSet.hpp
@@ -129,7 +129,7 @@ bool SetMixin<BaseSet>::add(value_type const& v) {
 template <typename BaseSet>
 bool SetMixin<BaseSet>::replace(value_type v) {
   bool replaced = remove(v);
-  Base::insert(move(v));
+  Base::insert(std::move(v));
   return replaced;
 }
 
@@ -170,7 +170,7 @@ auto SetMixin<BaseSet>::takeFirst() -> value_type {
   if (Base::empty())
     throw SetException("takeFirst called on empty set");
   auto i = Base::begin();
-  value_type v = move(*i);
+  value_type v = std::move(*i);
   Base::erase(i);
   return v;
 }
@@ -180,9 +180,9 @@ auto SetMixin<BaseSet>::maybeTakeFirst() -> Maybe<value_type> {
   if (Base::empty())
     return {};
   auto i = Base::begin();
-  value_type v = move(*i);
+  value_type v = std::move(*i);
   Base::erase(i);
-  return move(v);
+  return std::move(v);
 }
 
 template <typename BaseSet>
@@ -204,7 +204,7 @@ auto SetMixin<BaseSet>::takeLast() -> value_type {
   if (Base::empty())
     throw SetException("takeLast called on empty set");
   auto i = prev(Base::end());
-  value_type v = move(*i);
+  value_type v = std::move(*i);
   Base::erase(i);
   return v;
 }
@@ -214,9 +214,9 @@ auto SetMixin<BaseSet>::maybeTakeLast() -> Maybe<value_type> {
   if (Base::empty())
     return {};
   auto i = prev(Base::end());
-  value_type v = move(*i);
+  value_type v = std::move(*i);
   Base::erase(i);
-  return move(v);
+  return std::move(v);
 }
 
 template <typename BaseSet>
diff --git a/source/core/StarShellParser.cpp b/source/core/StarShellParser.cpp
index 31a927e..0551281 100644
--- a/source/core/StarShellParser.cpp
+++ b/source/core/StarShellParser.cpp
@@ -21,7 +21,7 @@ StringList ShellParser::tokenizeToStringList(String const& command) {
   StringList res;
   for (auto token : tokenize(command)) {
     if (token.type == TokenType::Word) {
-      res.append(move(token.token));
+      res.append(std::move(token.token));
     }
   }
 
diff --git a/source/core/StarSmallVector.hpp b/source/core/StarSmallVector.hpp
index 2a77a3d..77dc7a5 100644
--- a/source/core/StarSmallVector.hpp
+++ b/source/core/StarSmallVector.hpp
@@ -122,7 +122,7 @@ template <typename Element, size_t MaxStackSize>
 SmallVector<Element, MaxStackSize>::SmallVector(SmallVector&& other)
   : SmallVector() {
     for (auto& e : other)
-      emplace_back(move(e));
+      emplace_back(std::move(e));
 }
 
 template <typename Element, size_t MaxStackSize>
@@ -169,7 +169,7 @@ template <typename Element, size_t MaxStackSize>
 auto SmallVector<Element, MaxStackSize>::operator=(SmallVector&& other) -> SmallVector& {
   resize(other.size());
   for (size_t i = 0; i < size(); ++i)
-    operator[](i) = move(other[i]);
+    operator[](i) = std::move(other[i]);
 
   return *this;
 }
@@ -178,7 +178,7 @@ template <typename Element, size_t MaxStackSize>
 auto SmallVector<Element, MaxStackSize>::operator=(std::initializer_list<Element> list) -> SmallVector& {
   resize(list.size());
   for (size_t i = 0; i < size(); ++i)
-    operator[](i) = move(list[i]);
+    operator[](i) = std::move(list[i]);
   return *this;
 }
 
@@ -217,7 +217,7 @@ void SmallVector<Element, MaxStackSize>::reserve(size_t newCapacity) {
 
     // We assume that move constructors can never throw.
     for (size_t i = 0; i < size; ++i) {
-      new (&newMem[i]) Element(move(oldMem[i]));
+      new (&newMem[i]) Element(std::move(oldMem[i]));
     }
 
     m_begin = newMem;
@@ -313,7 +313,7 @@ Element* SmallVector<Element, MaxStackSize>::ptr() {
 
 template <typename Element, size_t MaxStackSize>
 void SmallVector<Element, MaxStackSize>::push_back(Element e) {
-  emplace_back(move(e));
+  emplace_back(std::move(e));
 }
 
 template <typename Element, size_t MaxStackSize>
@@ -326,7 +326,7 @@ void SmallVector<Element, MaxStackSize>::pop_back() {
 
 template <typename Element, size_t MaxStackSize>
 auto SmallVector<Element, MaxStackSize>::insert(iterator pos, Element e) -> iterator {
-  emplace(pos, move(e));
+  emplace(pos, std::move(e));
   return pos;
 }
 
@@ -341,7 +341,7 @@ auto SmallVector<Element, MaxStackSize>::insert(iterator pos, Iterator begin, It
   resize(size() + toAdd);
 
   for (size_t i = toShift; i != 0; --i)
-    operator[](endIndex + i - 1) = move(operator[](startIndex + i - 1));
+    operator[](endIndex + i - 1) = std::move(operator[](startIndex + i - 1));
 
   for (size_t i = 0; i != toAdd; ++i)
     operator[](startIndex + i) = *begin++;
@@ -360,8 +360,8 @@ void SmallVector<Element, MaxStackSize>::emplace(iterator pos, Args&&... args) {
   size_t index = pos - m_begin;
   emplace_back(Element());
   for (size_t i = size() - 1; i != index; --i)
-    operator[](i) = move(operator[](i - 1));
-  operator[](index) = Element(forward<Args>(args)...);
+    operator[](i) = std::move(operator[](i - 1));
+  operator[](index) = Element(std::forward<Args>(args)...);
 }
 
 template <typename Element, size_t MaxStackSize>
@@ -369,7 +369,7 @@ template <typename... Args>
 void SmallVector<Element, MaxStackSize>::emplace_back(Args&&... args) {
   if (m_end == m_capacity)
     reserve(size() + 1);
-  new (m_end) Element(forward<Args>(args)...);
+  new (m_end) Element(std::forward<Args>(args)...);
   ++m_end;
 }
 
@@ -383,7 +383,7 @@ template <typename Element, size_t MaxStackSize>
 auto SmallVector<Element, MaxStackSize>::erase(iterator pos) -> iterator {
   size_t index = pos - ptr();
   for (size_t i = index; i < size() - 1; ++i)
-    operator[](i) = move(operator[](i + 1));
+    operator[](i) = std::move(operator[](i + 1));
   pop_back();
   return pos;
 }
@@ -394,7 +394,7 @@ auto SmallVector<Element, MaxStackSize>::erase(iterator begin, iterator end) ->
   size_t endIndex = end - ptr();
   size_t toRemove = endIndex - startIndex;
   for (size_t i = endIndex; i < size(); ++i)
-    operator[](startIndex + (i - endIndex)) = move(operator[](i));
+    operator[](startIndex + (i - endIndex)) = std::move(operator[](i));
   resize(size() - toRemove);
   return begin;
 }
diff --git a/source/core/StarSocket.cpp b/source/core/StarSocket.cpp
index 9b866b8..dbe1439 100644
--- a/source/core/StarSocket.cpp
+++ b/source/core/StarSocket.cpp
@@ -96,7 +96,7 @@ Maybe<SocketPollResult> Socket::poll(SocketPollQuery const& query, unsigned time
       pr.exception = pfd.revents & POLLHUP || pfd.revents & POLLNVAL || pfd.revents & POLLERR;
       if (pfd.revents & POLLHUP)
         p.first.first->doShutdown();
-      result.add(p.first.first, move(pr));
+      result.add(p.first.first, std::move(pr));
     }
   }
 #endif
diff --git a/source/core/StarSpatialHash2D.hpp b/source/core/StarSpatialHash2D.hpp
index 2241dfd..87f70e3 100644
--- a/source/core/StarSpatialHash2D.hpp
+++ b/source/core/StarSpatialHash2D.hpp
@@ -239,19 +239,19 @@ void SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::set(Key con
 
 template <typename KeyT, typename ScalarT, typename ValueT, typename IntT, size_t AllocatorBlockSize>
 void SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::set(Key const& key, Coord const& pos, Value value) {
-  set(key, {Rect(pos, pos)}, move(value));
+  set(key, {Rect(pos, pos)}, std::move(value));
 }
 
 template <typename KeyT, typename ScalarT, typename ValueT, typename IntT, size_t AllocatorBlockSize>
 void SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::set(Key const& key, Rect const& rect, Value value) {
-  set(key, {rect}, move(value));
+  set(key, {rect}, std::move(value));
 }
 
 template <typename KeyT, typename ScalarT, typename ValueT, typename IntT, size_t AllocatorBlockSize>
 template <typename RectCollection>
 void SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::set(Key const& key, RectCollection const& rects, Value value) {
   Entry& entry = m_entryMap[key];
-  entry.value = move(value);
+  entry.value = std::move(value);
   updateSpatial(&entry, rects);
 }
 
@@ -262,7 +262,7 @@ auto SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::remove(Key
     return {};
 
   removeSpatial(&iter->second);
-  Maybe<Value> val = move(iter->second.value);
+  Maybe<Value> val = std::move(iter->second.value);
   m_entryMap.erase(iter);
   return val;
 }
diff --git a/source/core/StarStaticVector.hpp b/source/core/StarStaticVector.hpp
index 18ddaae..91a2e41 100644
--- a/source/core/StarStaticVector.hpp
+++ b/source/core/StarStaticVector.hpp
@@ -116,7 +116,7 @@ template <typename Element, size_t MaxSize>
 StaticVector<Element, MaxSize>::StaticVector(StaticVector&& other)
   : StaticVector() {
   for (auto& e : other)
-    emplace_back(move(e));
+    emplace_back(std::move(e));
 }
 
 template <typename Element, size_t MaxSize>
@@ -163,7 +163,7 @@ template <typename Element, size_t MaxSize>
 auto StaticVector<Element, MaxSize>::operator=(StaticVector&& other) -> StaticVector& {
   resize(other.size());
   for (size_t i = 0; i < m_size; ++i)
-    operator[](i) = move(other[i]);
+    operator[](i) = std::move(other[i]);
 
   return *this;
 }
@@ -172,7 +172,7 @@ template <typename Element, size_t MaxSize>
 auto StaticVector<Element, MaxSize>::operator=(std::initializer_list<Element> list) -> StaticVector& {
   resize(list.size());
   for (size_t i = 0; i < m_size; ++i)
-    operator[](i) = move(list[i]);
+    operator[](i) = std::move(list[i]);
   return *this;
 }
 
@@ -275,7 +275,7 @@ Element* StaticVector<Element, MaxSize>::ptr() {
 
 template <typename Element, size_t MaxSize>
 void StaticVector<Element, MaxSize>::push_back(Element e) {
-  emplace_back(move(e));
+  emplace_back(std::move(e));
 }
 
 template <typename Element, size_t MaxSize>
@@ -288,7 +288,7 @@ void StaticVector<Element, MaxSize>::pop_back() {
 
 template <typename Element, size_t MaxSize>
 auto StaticVector<Element, MaxSize>::insert(iterator pos, Element e) -> iterator {
-  emplace(pos, move(e));
+  emplace(pos, std::move(e));
   return pos;
 }
 
@@ -303,7 +303,7 @@ auto StaticVector<Element, MaxSize>::insert(iterator pos, Iterator begin, Iterat
   resize(m_size + toAdd);
 
   for (size_t i = toShift; i != 0; --i)
-    operator[](endIndex + i - 1) = move(operator[](startIndex + i - 1));
+    operator[](endIndex + i - 1) = std::move(operator[](startIndex + i - 1));
 
   for (size_t i = 0; i != toAdd; ++i)
     operator[](startIndex + i) = *begin++;
@@ -322,8 +322,8 @@ void StaticVector<Element, MaxSize>::emplace(iterator pos, Args&&... args) {
   size_t index = pos - ptr();
   resize(m_size + 1);
   for (size_t i = m_size - 1; i != index; --i)
-    operator[](i) = move(operator[](i - 1));
-  operator[](index) = Element(forward<Args>(args)...);
+    operator[](i) = std::move(operator[](i - 1));
+  operator[](index) = Element(std::forward<Args>(args)...);
 }
 
 template <typename Element, size_t MaxSize>
@@ -333,7 +333,7 @@ void StaticVector<Element, MaxSize>::emplace_back(Args&&... args) {
     throw StaticVectorSizeException::format("StaticVector::emplace_back would extend StaticVector beyond size {}", MaxSize);
 
   m_size += 1;
-  new (ptr() + m_size - 1) Element(forward<Args>(args)...);
+  new (ptr() + m_size - 1) Element(std::forward<Args>(args)...);
 }
 
 template <typename Element, size_t MaxSize>
@@ -346,7 +346,7 @@ template <typename Element, size_t MaxSize>
 auto StaticVector<Element, MaxSize>::erase(iterator pos) -> iterator {
   size_t index = pos - ptr();
   for (size_t i = index; i < m_size - 1; ++i)
-    operator[](i) = move(operator[](i + 1));
+    operator[](i) = std::move(operator[](i + 1));
   resize(m_size - 1);
   return pos;
 }
@@ -357,7 +357,7 @@ auto StaticVector<Element, MaxSize>::erase(iterator begin, iterator end) -> iter
   size_t endIndex = end - ptr();
   size_t toRemove = endIndex - startIndex;
   for (size_t i = endIndex; i < m_size; ++i)
-    operator[](startIndex + (i - endIndex)) = move(operator[](i));
+    operator[](startIndex + (i - endIndex)) = std::move(operator[](i));
   resize(m_size - toRemove);
   return begin;
 }
diff --git a/source/core/StarString.cpp b/source/core/StarString.cpp
index f76c707..b236656 100644
--- a/source/core/StarString.cpp
+++ b/source/core/StarString.cpp
@@ -343,7 +343,7 @@ StringList String::splitAny(String const& chars, size_t maxSplit) const {
     }
   }
   if (!next.empty())
-    ret.append(move(next));
+    ret.append(std::move(next));
   return ret;
 }
 
@@ -661,43 +661,43 @@ void String::append(Char c) {
 void String::prepend(String const& s) {
   auto ns = s;
   ns.append(*this);
-  *this = move(ns);
+  *this = std::move(ns);
 }
 
 void String::prepend(std::string const& s) {
   auto ns = String(s);
   ns.append(*this);
-  *this = move(ns);
+  *this = std::move(ns);
 }
 
 void String::prepend(Char const* s) {
   auto ns = String(s);
   ns.append(*this);
-  *this = move(ns);
+  *this = std::move(ns);
 }
 
 void String::prepend(Char const* s, size_t n) {
   auto ns = String(s, n);
   ns.append(*this);
-  *this = move(ns);
+  *this = std::move(ns);
 }
 
 void String::prepend(char const* s) {
   auto ns = String(s);
   ns.append(*this);
-  *this = move(ns);
+  *this = std::move(ns);
 }
 
 void String::prepend(char const* s, size_t n) {
   auto ns = String(s, n);
   ns.append(*this);
-  *this = move(ns);
+  *this = std::move(ns);
 }
 
 void String::prepend(Char c) {
   auto ns = String(c, 1);
   ns.append(*this);
-  *this = move(ns);
+  *this = std::move(ns);
 }
 
 void String::push_back(Char c) {
@@ -809,7 +809,7 @@ String& String::operator=(String const& s) {
 }
 
 String& String::operator=(String&& s) {
-  m_string = move(s.m_string);
+  m_string = std::move(s.m_string);
   return *this;
 }
 
diff --git a/source/core/StarString.hpp b/source/core/StarString.hpp
index 242d54c..10f5b9f 100644
--- a/source/core/StarString.hpp
+++ b/source/core/StarString.hpp
@@ -473,7 +473,7 @@ Maybe<String> String::maybeLookupTagsView(Lookup&& lookup) const {
 template <typename Lookup>
 String String::lookupTagsView(Lookup&& lookup) const {
   auto result = maybeLookupTagsView(lookup);
-  return result ? move(result.take()) : String();
+  return result ? std::move(result.take()) : String();
 }
 
 template <typename MapType>
diff --git a/source/core/StarStringView.cpp b/source/core/StarStringView.cpp
index 4b45fe6..2bc9cd5 100644
--- a/source/core/StarStringView.cpp
+++ b/source/core/StarStringView.cpp
@@ -17,13 +17,13 @@ String& String::operator+=(std::string_view s) {
 
 StringView::StringView() {}
 StringView::StringView(StringView const& s) : m_view(s.m_view) {}
-StringView::StringView(StringView&& s) noexcept : m_view(move(s.m_view)) {};
+StringView::StringView(StringView&& s) noexcept : m_view(std::move(s.m_view)) {};
 StringView::StringView(String const& s) : m_view(s.utf8()) {};
 StringView::StringView(char const* s) : m_view(s) {};
 StringView::StringView(char const* s, size_t n) : m_view(s, n) {};
 
 StringView::StringView(std::string_view const& s) : m_view(s) {};
-StringView::StringView(std::string_view&& s) noexcept : m_view(move(s)) {};
+StringView::StringView(std::string_view&& s) noexcept : m_view(std::move(s)) {};
 StringView::StringView(std::string const& s) : m_view(s) {}
 
 StringView::StringView(Char const* s) : m_view((char const*)s, sizeof(*s)) {}
diff --git a/source/core/StarThread.hpp b/source/core/StarThread.hpp
index 5d2c69f..25d51b6 100644
--- a/source/core/StarThread.hpp
+++ b/source/core/StarThread.hpp
@@ -352,7 +352,7 @@ bool MLocker<MutexType>::tryLock() {
 
 template <typename Function, typename... Args>
 ThreadFunction<decltype(std::declval<Function>()(std::declval<Args>()...))> Thread::invoke(String const& name, Function&& f, Args&&... args) {
-  return {bind(forward<Function>(f), forward<Args>(args)...), name};
+  return {bind(std::forward<Function>(f), std::forward<Args>(args)...), name};
 }
 
 template <typename Return>
@@ -364,7 +364,7 @@ ThreadFunction<Return>::ThreadFunction(ThreadFunction&&) = default;
 template <typename Return>
 ThreadFunction<Return>::ThreadFunction(function<Return()> function, String const& name) {
   m_return = make_shared<Maybe<Return>>();
-  m_function = ThreadFunction<void>([function = move(function), retValue = m_return]() {
+  m_function = ThreadFunction<void>([function = std::move(function), retValue = m_return]() {
       *retValue = function();
     }, name);
 }
diff --git a/source/core/StarThread_unix.cpp b/source/core/StarThread_unix.cpp
index 6fcb0f9..7fbf279 100644
--- a/source/core/StarThread_unix.cpp
+++ b/source/core/StarThread_unix.cpp
@@ -101,10 +101,10 @@ struct ThreadImpl {
 
 struct ThreadFunctionImpl : ThreadImpl {
   ThreadFunctionImpl(std::function<void()> function, String name)
-    : ThreadImpl(wrapFunction(move(function)), move(name)) {}
+    : ThreadImpl(wrapFunction(std::move(function)), std::move(name)) {}
 
   std::function<void()> wrapFunction(std::function<void()> function) {
-    return [function = move(function), this]() {
+    return [function = std::move(function), this]() {
       try {
         function();
       } catch (...) {
@@ -283,7 +283,7 @@ ThreadFunction<void>::ThreadFunction() {}
 ThreadFunction<void>::ThreadFunction(ThreadFunction&&) = default;
 
 ThreadFunction<void>::ThreadFunction(function<void()> function, String const& name) {
-  m_impl.reset(new ThreadFunctionImpl(move(function), name));
+  m_impl.reset(new ThreadFunctionImpl(std::move(function), name));
   m_impl->start();
 }
 
diff --git a/source/core/StarThread_windows.cpp b/source/core/StarThread_windows.cpp
index 7a60f56..a7d09be 100644
--- a/source/core/StarThread_windows.cpp
+++ b/source/core/StarThread_windows.cpp
@@ -106,10 +106,10 @@ private:
 
 struct ThreadFunctionImpl : ThreadImpl {
   ThreadFunctionImpl(std::function<void()> function, String name)
-    : ThreadImpl(wrapFunction(move(function)), move(name)) {}
+    : ThreadImpl(wrapFunction(std::move(function)), std::move(name)) {}
 
   std::function<void()> wrapFunction(std::function<void()> function) {
-    return [function = move(function), this]() {
+    return [function = std::move(function), this]() {
       try {
         function();
       } catch (...) {
@@ -437,7 +437,7 @@ ThreadFunction<void>::ThreadFunction() {}
 ThreadFunction<void>::ThreadFunction(ThreadFunction&&) = default;
 
 ThreadFunction<void>::ThreadFunction(function<void()> function, String const& name) {
-  m_impl.reset(new ThreadFunctionImpl(move(function), name));
+  m_impl.reset(new ThreadFunctionImpl(std::move(function), name));
   m_impl->start();
 }
 
diff --git a/source/core/StarTtlCache.hpp b/source/core/StarTtlCache.hpp
index c70741a..0824880 100644
--- a/source/core/StarTtlCache.hpp
+++ b/source/core/StarTtlCache.hpp
@@ -134,7 +134,7 @@ template <typename LruCacheType>
 auto TtlCacheBase<LruCacheType>::values() const -> List<Value> {
   List<Value> values;
   for (auto& p : m_cache.values())
-    values.append(move(p.second));
+    values.append(std::move(p.second));
   return values;
 }
 
diff --git a/source/core/StarVariant.hpp b/source/core/StarVariant.hpp
index 39779c1..d70d960 100644
--- a/source/core/StarVariant.hpp
+++ b/source/core/StarVariant.hpp
@@ -75,7 +75,7 @@ public:
     typename std::enable_if< std::is_constructible<T, Args...>::value, int >::type = 0
   >
   Variant(std::in_place_type_t<T>, Args&&... args) {
-    new (&m_buffer) T(forward<Args>(args)...);
+    new (&m_buffer) T(std::forward<Args>(args)...);
     m_typeIndex = TypeIndex<T>::value;
   }
 
@@ -83,7 +83,7 @@ public:
     typename std::enable_if< std::is_constructible<T, std::initializer_list<U>&, Args...>::value, int >::type = 0
   >
   Variant(std::in_place_type_t<T>, std::initializer_list<U> il, Args&&... args) {
-    new (&m_buffer) T(il, forward<Args>(args)...);
+    new (&m_buffer) T(il, std::forward<Args>(args)...);
     m_typeIndex = TypeIndex<T>::value;
   }
 
@@ -373,12 +373,12 @@ Variant<FirstType, RestTypes...>::Variant(T const& x) {
 template <typename FirstType, typename... RestTypes>
 template <typename T, typename>
 Variant<FirstType, RestTypes...>::Variant(T&& x) {
-  assign(forward<T>(x));
+  assign(std::forward<T>(x));
 }
 
 template <typename FirstType, typename... RestTypes>
 Variant<FirstType, RestTypes...>::Variant(Variant const& x) {
-  x.call([this](auto const& t) {
+  x.call([&](auto const& t) {
       assign(t);
     });
 }
@@ -386,8 +386,8 @@ Variant<FirstType, RestTypes...>::Variant(Variant const& x) {
 template <typename FirstType, typename... RestTypes>
 Variant<FirstType, RestTypes...>::Variant(Variant&& x)
   noexcept(detail::IsNothrowMoveConstructible<FirstType, RestTypes...>::value) {
-  x.call([this](auto& t) {
-      assign(move(t));
+  x.call([&](auto& t) {
+      assign(std::move(t));
     });
 }
 
@@ -401,7 +401,7 @@ Variant<FirstType, RestTypes...>& Variant<FirstType, RestTypes...>::operator=(Va
   if (&x == this)
     return *this;
 
-  x.call([this](auto const& t) {
+  x.call([&](auto const& t) {
       assign(t);
     });
 
@@ -414,8 +414,8 @@ Variant<FirstType, RestTypes...>& Variant<FirstType, RestTypes...>::operator=(Va
   if (&x == this)
     return *this;
 
-  x.call([this](auto& t) {
-      assign(move(t));
+  x.call([&](auto& t) {
+      assign(std::move(t));
     });
 
   return *this;
@@ -431,7 +431,7 @@ Variant<FirstType, RestTypes...>& Variant<FirstType, RestTypes...>::operator=(T
 template <typename FirstType, typename... RestTypes>
 template <typename T, typename>
 Variant<FirstType, RestTypes...>& Variant<FirstType, RestTypes...>::operator=(T&& x) {
-  assign(forward<T>(x));
+  assign(std::forward<T>(x));
   return *this;
 }
 
@@ -484,13 +484,13 @@ bool Variant<FirstType, RestTypes...>::is() const {
 template <typename FirstType, typename... RestTypes>
 template <typename Function>
 decltype(auto) Variant<FirstType, RestTypes...>::call(Function&& function) {
-  return doCall<Function, FirstType, RestTypes...>(forward<Function>(function));
+  return doCall<Function, FirstType, RestTypes...>(std::forward<Function>(function));
 }
 
 template <typename FirstType, typename... RestTypes>
 template <typename Function>
 decltype(auto) Variant<FirstType, RestTypes...>::call(Function&& function) const {
-  return doCall<Function, FirstType, RestTypes...>(forward<Function>(function));
+  return doCall<Function, FirstType, RestTypes...>(std::forward<Function>(function));
 }
 
 template <typename FirstType, typename... RestTypes>
@@ -588,10 +588,10 @@ template <typename T>
 void Variant<FirstType, RestTypes...>::assign(T&& x) {
   typedef typename std::decay<T>::type AssignType;
   if (auto p = ptr<AssignType>()) {
-    *p = forward<T>(x);
+    *p = std::forward<T>(x);
   } else {
     destruct();
-    new (&m_buffer) AssignType(forward<T>(x));
+    new (&m_buffer) AssignType(std::forward<T>(x));
     m_typeIndex = TypeIndex<AssignType>::value;
   }
 }
@@ -611,7 +611,7 @@ decltype(auto) Variant<FirstType, RestTypes...>::doCall(Function&& function) {
   if (T1* p = ptr<T1>())
     return function(*p);
   else
-    return doCall<Function, T2, TL...>(forward<Function>(function));
+    return doCall<Function, T2, TL...>(std::forward<Function>(function));
 }
 
 template <typename FirstType, typename... RestTypes>
@@ -629,7 +629,7 @@ decltype(auto) Variant<FirstType, RestTypes...>::doCall(Function&& function) con
   if (T1 const* p = ptr<T1>())
     return function(*p);
   else
-    return doCall<Function, T2, TL...>(forward<Function>(function));
+    return doCall<Function, T2, TL...>(std::forward<Function>(function));
 }
 
 template <typename FirstType, typename... RestTypes>
@@ -665,7 +665,7 @@ MVariant<Types...>::MVariant(MVariant const& x)
 
 template <typename... Types>
 MVariant<Types...>::MVariant(MVariant&& x) {
-  m_variant = move(x.m_variant);
+  m_variant = std::move(x.m_variant);
   x.m_variant = MVariantEmpty();
 }
 
@@ -676,7 +676,7 @@ MVariant<Types...>::MVariant(Variant<Types...> const& x) {
 
 template <typename... Types>
 MVariant<Types...>::MVariant(Variant<Types...>&& x) {
-  operator=(move(x));
+  operator=(std::move(x));
 }
 
 template <typename... Types>
@@ -687,7 +687,7 @@ MVariant<Types...>::MVariant(T const& x)
 template <typename... Types>
 template <typename T, typename>
 MVariant<Types...>::MVariant(T&& x)
-  : m_variant(forward<T>(x)) {}
+  : m_variant(std::forward<T>(x)) {}
 
 template <typename... Types>
 MVariant<Types...>::~MVariant() {}
@@ -707,7 +707,7 @@ MVariant<Types...>& MVariant<Types...>::operator=(MVariant const& x) {
 template <typename... Types>
 MVariant<Types...>& MVariant<Types...>::operator=(MVariant&& x) {
   try {
-    m_variant = move(x.m_variant);
+    m_variant = std::move(x.m_variant);
   } catch (...) {
     if (m_variant.invalid())
       m_variant = MVariantEmpty();
@@ -733,7 +733,7 @@ template <typename... Types>
 template <typename T, typename>
 MVariant<Types...>& MVariant<Types...>::operator=(T&& x) {
   try {
-    m_variant = forward<T>(x);
+    m_variant = std::forward<T>(x);
   } catch (...) {
     if (m_variant.invalid())
       m_variant = MVariantEmpty();
@@ -753,7 +753,7 @@ MVariant<Types...>& MVariant<Types...>::operator=(Variant<Types...> const& x) {
 template <typename... Types>
 MVariant<Types...>& MVariant<Types...>::operator=(Variant<Types...>&& x) {
   x.call([this](auto& t) {
-      *this = move(t);
+      *this = std::move(t);
     });
   return *this;
 }
@@ -830,7 +830,7 @@ bool MVariant<Types...>::is() const {
 template <typename... Types>
 template <typename T, typename>
 T MVariant<Types...>::take() {
-  T t = move(m_variant.template get<T>());
+  T t = std::move(m_variant.template get<T>());
   m_variant = MVariantEmpty();
   return t;
 }
@@ -854,7 +854,7 @@ Variant<Types...> MVariant<Types...>::takeValue() {
 
   Variant<Types...> r;
   call([&r](auto& v) {
-      r = move(v);
+      r = std::move(v);
     });
   m_variant = MVariantEmpty();
   return r;
@@ -878,13 +878,13 @@ MVariant<Types...>::operator bool() const {
 template <typename... Types>
 template <typename Function>
 void MVariant<Types...>::call(Function&& function) {
-  m_variant.call(RefCaller<Function>(forward<Function>(function)));
+  m_variant.call(RefCaller<Function>(std::forward<Function>(function)));
 }
 
 template <typename... Types>
 template <typename Function>
 void MVariant<Types...>::call(Function&& function) const {
-  m_variant.call(ConstRefCaller<Function>(forward<Function>(function)));
+  m_variant.call(ConstRefCaller<Function>(std::forward<Function>(function)));
 }
 
 template <typename... Types>
@@ -910,7 +910,7 @@ bool MVariant<Types...>::MVariantEmpty::operator<(MVariantEmpty const&) const {
 template <typename... Types>
 template <typename Function>
 MVariant<Types...>::RefCaller<Function>::RefCaller(Function&& function)
-  : function(forward<Function>(function)) {}
+  : function(std::forward<Function>(function)) {}
 
 template <typename... Types>
 template <typename Function>
@@ -926,7 +926,7 @@ void MVariant<Types...>::RefCaller<Function>::operator()(T& t) {
 template <typename... Types>
 template <typename Function>
 MVariant<Types...>::ConstRefCaller<Function>::ConstRefCaller(Function&& function)
-  : function(forward<Function>(function)) {}
+  : function(std::forward<Function>(function)) {}
 
 template <typename... Types>
 template <typename Function>
diff --git a/source/core/StarWeightedPool.hpp b/source/core/StarWeightedPool.hpp
index c335d31..ce09f40 100644
--- a/source/core/StarWeightedPool.hpp
+++ b/source/core/StarWeightedPool.hpp
@@ -69,7 +69,7 @@ void WeightedPool<Item>::add(double weight, Item item) {
   if (weight <= 0.0)
     return;
 
-  m_items.append({weight, move(item)});
+  m_items.append({weight, std::move(item)});
   m_totalWeight += weight;
 }
 
diff --git a/source/core/StarWorkerPool.cpp b/source/core/StarWorkerPool.cpp
index 2a7003d..f618682 100644
--- a/source/core/StarWorkerPool.cpp
+++ b/source/core/StarWorkerPool.cpp
@@ -39,11 +39,11 @@ void WorkerPoolHandle::finish() const {
 
 WorkerPoolHandle::Impl::Impl() : done(false) {}
 
-WorkerPoolHandle::WorkerPoolHandle(shared_ptr<Impl> impl) : m_impl(move(impl)) {}
+WorkerPoolHandle::WorkerPoolHandle(shared_ptr<Impl> impl) : m_impl(std::move(impl)) {}
 
-WorkerPool::WorkerPool(String name) : m_name(move(name)) {}
+WorkerPool::WorkerPool(String name) : m_name(std::move(name)) {}
 
-WorkerPool::WorkerPool(String name, unsigned threadCount) : WorkerPool(move(name)) {
+WorkerPool::WorkerPool(String name, unsigned threadCount) : WorkerPool(std::move(name)) {
   start(threadCount);
 }
 
@@ -159,7 +159,7 @@ void WorkerPool::WorkerThread::run() {
 
 void WorkerPool::queueWork(function<void()> work) {
   MutexLocker workLock(m_workMutex);
-  m_pendingWork.append(move(work));
+  m_pendingWork.append(std::move(work));
   m_workCondition.signal();
 }
 
diff --git a/source/core/StarWorkerPool.hpp b/source/core/StarWorkerPool.hpp
index 8d87bcb..fcbd41c 100644
--- a/source/core/StarWorkerPool.hpp
+++ b/source/core/StarWorkerPool.hpp
@@ -194,7 +194,7 @@ ResultType const& WorkerPoolPromise<ResultType>::get() const {
 
 template <typename ResultType>
 WorkerPoolPromise<ResultType>::WorkerPoolPromise(shared_ptr<Impl> impl)
-  : m_impl(move(impl)) {}
+  : m_impl(std::move(impl)) {}
 
 template <typename ResultType>
 WorkerPoolPromise<ResultType> WorkerPool::addProducer(function<ResultType()> producer) {
@@ -205,7 +205,7 @@ WorkerPoolPromise<ResultType> WorkerPool::addProducer(function<ResultType()> pro
     try {
       auto result = producer();
       MutexLocker promiseLocker(workerPoolPromiseImpl->mutex);
-      workerPoolPromiseImpl->result = move(result);
+      workerPoolPromiseImpl->result = std::move(result);
       workerPoolPromiseImpl->condition.broadcast();
     } catch (...) {
       MutexLocker promiseLocker(workerPoolPromiseImpl->mutex);
diff --git a/source/frontend/StarActionBar.cpp b/source/frontend/StarActionBar.cpp
index acaa3d1..15e1bd5 100644
--- a/source/frontend/StarActionBar.cpp
+++ b/source/frontend/StarActionBar.cpp
@@ -20,7 +20,7 @@ namespace Star {
 
 ActionBar::ActionBar(MainInterfacePaneManager* paneManager, PlayerPtr player) {
   m_paneManager = paneManager;
-  m_player = move(player);
+  m_player = std::move(player);
 
   auto assets = Root::singleton().assets();
 
diff --git a/source/frontend/StarAiInterface.cpp b/source/frontend/StarAiInterface.cpp
index 599b829..7bdea39 100644
--- a/source/frontend/StarAiInterface.cpp
+++ b/source/frontend/StarAiInterface.cpp
@@ -388,7 +388,7 @@ void AiInterface::setFaceAnimation(String const& name) {
 }
 
 void AiInterface::setCurrentSpeech(String const& textWidget, AiSpeech speech) {;
-  m_currentSpeech = move(speech);
+  m_currentSpeech = std::move(speech);
   m_textLength = 0.0;
   m_textMaxLength = Text::stripEscapeCodes(m_currentSpeech->text).size();
   m_currentTextWidget = findChild<LabelWidget>(textWidget);
diff --git a/source/frontend/StarBaseScriptPane.hpp b/source/frontend/StarBaseScriptPane.hpp
index 37070f1..9b7c38a 100644
--- a/source/frontend/StarBaseScriptPane.hpp
+++ b/source/frontend/StarBaseScriptPane.hpp
@@ -34,7 +34,7 @@ public:
   PanePtr createTooltip(Vec2I const& screenPosition) override;
   Maybe<String> cursorOverride(Vec2I const& screenPosition) override;
 protected:
-  virtual GuiReaderPtr reader();
+  virtual GuiReaderPtr reader() override;
   Json m_config;
   Json m_rawConfig;
 
diff --git a/source/frontend/StarChat.cpp b/source/frontend/StarChat.cpp
index 72c1409..230f3d9 100644
--- a/source/frontend/StarChat.cpp
+++ b/source/frontend/StarChat.cpp
@@ -191,7 +191,7 @@ void Chat::addMessages(List<ChatReceivedMessage> const& messages, bool showPane)
       m_receivedMessages.prepend({
           message.context.mode,
           message.portrait,
-          move(lines[i])
+          std::move(lines[i])
         });
     }
 
diff --git a/source/frontend/StarChatBubbleManager.cpp b/source/frontend/StarChatBubbleManager.cpp
index 166eba0..3137353 100644
--- a/source/frontend/StarChatBubbleManager.cpp
+++ b/source/frontend/StarChatBubbleManager.cpp
@@ -265,12 +265,12 @@ void ChatBubbleManager::addChatActions(List<ChatAction> chatActions, bool silent
       RectF boundBox = fold(backgroundImages, RectF::null(), [pos, this](RectF const& boundBox, BubbleImage const& bubbleImage) {
           return boundBox.combined(bubbleImageRect(pos, bubbleImage, m_zoom));
         });
-      Bubble bubble = {sayAction.entity, sayAction.text, sayAction.config, 0, move(backgroundImages), move(bubbleTexts), false};
+      Bubble bubble = {sayAction.entity, sayAction.text, sayAction.config, 0, std::move(backgroundImages), std::move(bubbleTexts), false};
       List<BubbleState<Bubble>> oldBubbles = m_bubbles.filtered([&sayAction](BubbleState<Bubble> const&, Bubble const& bubble) {
           return bubble.entity == sayAction.entity;
         });
       m_bubbles.filter([&sayAction](BubbleState<Bubble> const&, Bubble const& bubble) { return bubble.entity != sayAction.entity; });
-      m_bubbles.addBubble(pos, boundBox, move(bubble), m_interBubbleMargin * m_zoom);
+      m_bubbles.addBubble(pos, boundBox, std::move(bubble), m_interBubbleMargin * m_zoom);
       oldBubbles.sort([](BubbleState<Bubble> const& a, BubbleState<Bubble> const& b) { return a.contents.age < b.contents.age; });
       for (auto bubble : oldBubbles.slice(0, m_maxMessagePerEntity - 1))
         m_bubbles.addBubble(bubble.idealDestination, bubble.boundBox, bubble.contents, 0);
@@ -300,8 +300,8 @@ void ChatBubbleManager::addChatActions(List<ChatAction> chatActions, bool silent
           portraitAction.position,
           portraitAction.config,
           0,
-          move(backgroundImages),
-          move(bubbleTexts),
+          std::move(backgroundImages),
+          std::move(bubbleTexts),
           false
         });
     }
diff --git a/source/frontend/StarChatBubbleSeparation.hpp b/source/frontend/StarChatBubbleSeparation.hpp
index 4bbf018..dfe5167 100644
--- a/source/frontend/StarChatBubbleSeparation.hpp
+++ b/source/frontend/StarChatBubbleSeparation.hpp
@@ -112,7 +112,7 @@ void BubbleSeparator<T>::addBubble(Vec2F position, RectF boundBox, T contents, u
   Vec2F separatedOffset = separated.min() - boundBox.min();
   Vec2F separatedPosition = position + separatedOffset;
   Bubble bubble = Bubble{ contents, position, position, boundBox, separatedOffset, separated, separatedOffset, separatedPosition };
-  m_bubbles.insertSorted(move(bubble), &BubbleSeparator<T>::compareBubbleY);
+  m_bubbles.insertSorted(std::move(bubble), &BubbleSeparator<T>::compareBubbleY);
 }
 
 template <typename T>
@@ -136,8 +136,8 @@ template <typename T>
 void BubbleSeparator<T>::forEach(function<void(Bubble&, T&)> func) {
   bool anyMoved = false;
   
-  List<Box<float, 2>> leftEdges = move(m_sortedLeftEdges);
-  List<Box<float, 2>> rightEdges = move(m_sortedRightEdges);
+  List<Box<float, 2>> leftEdges = std::move(m_sortedLeftEdges);
+  List<Box<float, 2>> rightEdges = std::move(m_sortedRightEdges);
 
   m_bubbles.exec([this, func, &anyMoved, &leftEdges, &rightEdges](Bubble& bubble) {
     RectF oldBoundBox = bubble.boundBox;
diff --git a/source/frontend/StarCinematic.cpp b/source/frontend/StarCinematic.cpp
index 7b095a6..ade940d 100644
--- a/source/frontend/StarCinematic.cpp
+++ b/source/frontend/StarCinematic.cpp
@@ -196,7 +196,7 @@ void Cinematic::render() {
       drawable.scale(values.zoom);
       drawable.translate(values.position);
       drawable.color *= alphaColor;
-      drawDrawable(move(drawable), drawableScale, drawableTranslation);
+      drawDrawable(std::move(drawable), drawableScale, drawableTranslation);
     }
     if (!panel->avatar.empty() && m_player) {
       for (auto drawable : m_player->portrait(PortraitModeNames.getLeft(panel->avatar))) {
@@ -204,7 +204,7 @@ void Cinematic::render() {
         drawable.scale(values.zoom);
         drawable.translate(values.position);
         drawable.color *= alphaColor;
-        drawDrawable(move(drawable), drawableScale, drawableTranslation);
+        drawDrawable(std::move(drawable), drawableScale, drawableTranslation);
       }
     }
     if (!panel->text.empty()) {
@@ -273,7 +273,7 @@ void Cinematic::drawDrawable(Drawable const& drawable, float drawableScale, Vec2
 
     Vec4B drawableColor = drawable.color.toRgba();
 
-    primitives.emplace_back(std::in_place_type_t<RenderQuad>(), move(texture),
+    primitives.emplace_back(std::in_place_type_t<RenderQuad>(), std::move(texture),
         lowerLeft,  Vec2F{0, 0},
         lowerRight, Vec2F{size[0], 0},
         upperRight, Vec2F{size[0], size[1]},
diff --git a/source/frontend/StarClientCommandProcessor.cpp b/source/frontend/StarClientCommandProcessor.cpp
index 933d87b..8434043 100644
--- a/source/frontend/StarClientCommandProcessor.cpp
+++ b/source/frontend/StarClientCommandProcessor.cpp
@@ -16,8 +16,8 @@ namespace Star {
 
 ClientCommandProcessor::ClientCommandProcessor(UniverseClientPtr universeClient, CinematicPtr cinematicOverlay,
     MainInterfacePaneManager* paneManager, StringMap<StringList> macroCommands)
-  : m_universeClient(move(universeClient)), m_cinematicOverlay(move(cinematicOverlay)),
-    m_paneManager(paneManager), m_macroCommands(move(macroCommands)) {
+  : m_universeClient(std::move(universeClient)), m_cinematicOverlay(std::move(cinematicOverlay)),
+    m_paneManager(paneManager), m_macroCommands(std::move(macroCommands)) {
   m_builtinCommands = {
     {"reload", bind(&ClientCommandProcessor::reload, this)},
     {"whoami", bind(&ClientCommandProcessor::whoami, this)},
diff --git a/source/frontend/StarConfirmationDialog.cpp b/source/frontend/StarConfirmationDialog.cpp
index 0fdad09..038ebef 100644
--- a/source/frontend/StarConfirmationDialog.cpp
+++ b/source/frontend/StarConfirmationDialog.cpp
@@ -29,8 +29,8 @@ void ConfirmationDialog::displayConfirmation(Json const& dialogConfig, WidgetCal
 
   GuiReader reader;
 
-  m_okCallback = move(okCallback);
-  m_cancelCallback = move(cancelCallback);
+  m_okCallback = std::move(okCallback);
+  m_cancelCallback = std::move(cancelCallback);
 
   reader.registerCallback("close", bind(&ConfirmationDialog::dismiss, this));
   reader.registerCallback("cancel", bind(&ConfirmationDialog::dismiss, this));
diff --git a/source/frontend/StarContainerInteractor.cpp b/source/frontend/StarContainerInteractor.cpp
index 2500f77..47a9de2 100644
--- a/source/frontend/StarContainerInteractor.cpp
+++ b/source/frontend/StarContainerInteractor.cpp
@@ -5,7 +5,7 @@ namespace Star {
 void ContainerInteractor::openContainer(ContainerEntityPtr containerEntity) {
   if (m_openContainer && m_openContainer->inWorld())
     m_openContainer->containerClose();
-  m_openContainer = move(containerEntity);
+  m_openContainer = std::move(containerEntity);
   if (m_openContainer) {
     starAssert(m_openContainer->inWorld());
     m_openContainer->containerOpen();
diff --git a/source/frontend/StarContainerInterface.cpp b/source/frontend/StarContainerInterface.cpp
index d69138a..5a06d04 100644
--- a/source/frontend/StarContainerInterface.cpp
+++ b/source/frontend/StarContainerInterface.cpp
@@ -24,7 +24,7 @@ namespace Star {
 ContainerPane::ContainerPane(WorldClientPtr worldClient, PlayerPtr player, ContainerInteractorPtr containerInteractor) {
   m_worldClient = worldClient;
   m_player = player;
-  m_containerInteractor = move(containerInteractor);
+  m_containerInteractor = std::move(containerInteractor);
 
   auto container = m_containerInteractor->openContainer();
   auto guiConfig = container->containerGuiConfig();
diff --git a/source/frontend/StarCraftingInterface.cpp b/source/frontend/StarCraftingInterface.cpp
index b363b92..34e0265 100644
--- a/source/frontend/StarCraftingInterface.cpp
+++ b/source/frontend/StarCraftingInterface.cpp
@@ -29,8 +29,8 @@
 namespace Star {
 
 CraftingPane::CraftingPane(WorldClientPtr worldClient, PlayerPtr player, Json const& settings, EntityId sourceEntityId) {
-  m_worldClient = move(worldClient);
-  m_player = move(player);
+  m_worldClient = std::move(worldClient);
+  m_player = std::move(player);
   m_blueprints = m_player->blueprints();
   m_recipeAutorefreshCooldown = 0;
   m_sourceEntityId = sourceEntityId;
diff --git a/source/frontend/StarInterfaceLuaBindings.cpp b/source/frontend/StarInterfaceLuaBindings.cpp
index e64a92b..a023a71 100644
--- a/source/frontend/StarInterfaceLuaBindings.cpp
+++ b/source/frontend/StarInterfaceLuaBindings.cpp
@@ -30,7 +30,7 @@ LuaCallbacks LuaBindings::makeInterfaceCallbacks(MainInterface* mainInterface) {
       paneManager->displayRegisteredPane(pane);
   });
 
-  callbacks.registerCallback("scale", [mainInterface]() -> int {
+  callbacks.registerCallback("scale", []() -> int {
     return GuiContext::singleton().interfaceScale();
   });
 
diff --git a/source/frontend/StarInventory.cpp b/source/frontend/StarInventory.cpp
index b73b33e..390558c 100644
--- a/source/frontend/StarInventory.cpp
+++ b/source/frontend/StarInventory.cpp
@@ -25,8 +25,8 @@ namespace Star {
 
 InventoryPane::InventoryPane(MainInterface* parent, PlayerPtr player, ContainerInteractorPtr containerInteractor) {
   m_parent = parent;
-  m_player = move(player);
-  m_containerInteractor = move(containerInteractor);
+  m_player = std::move(player);
+  m_containerInteractor = std::move(containerInteractor);
 
   GuiReader invWindowReader;
   auto config = Root::singleton().assets()->json("/interface/windowconfig/playerinventory.config");
diff --git a/source/frontend/StarJoinRequestDialog.cpp b/source/frontend/StarJoinRequestDialog.cpp
index 1966265..0bc71d8 100644
--- a/source/frontend/StarJoinRequestDialog.cpp
+++ b/source/frontend/StarJoinRequestDialog.cpp
@@ -18,7 +18,7 @@ void JoinRequestDialog::displayRequest(String const& userName, function<void(P2P
 
   GuiReader reader;
 
-  m_callback = move(callback);
+  m_callback = std::move(callback);
 
   reader.registerCallback("yes", [this](Widget*){ reply(P2PJoinRequestReply::Yes); });
   reader.registerCallback("no", [this](Widget*){ reply(P2PJoinRequestReply::No); });
diff --git a/source/frontend/StarMainInterface.cpp b/source/frontend/StarMainInterface.cpp
index b7c93d1..0c84933 100644
--- a/source/frontend/StarMainInterface.cpp
+++ b/source/frontend/StarMainInterface.cpp
@@ -1130,7 +1130,7 @@ void MainInterface::renderMonsterHealthBar() {
     Drawable::scaleAll(portrait, 1.0f / m_portraitScale);
 
     for (auto drawable : portrait)
-      m_guiContext->drawDrawable(move(drawable), backgroundCenterPos + portraitOffset, portraitScale);
+      m_guiContext->drawDrawable(std::move(drawable), backgroundCenterPos + portraitOffset, portraitScale);
 
     m_guiContext->resetInterfaceScissorRect();
   }
diff --git a/source/frontend/StarMainMixer.cpp b/source/frontend/StarMainMixer.cpp
index a0f5e2b..fe676d5 100644
--- a/source/frontend/StarMainMixer.cpp
+++ b/source/frontend/StarMainMixer.cpp
@@ -16,11 +16,11 @@ MainMixer::MainMixer(unsigned sampleRate, unsigned channels) {
 }
 
 void MainMixer::setUniverseClient(UniverseClientPtr universeClient) {
-  m_universeClient = move(universeClient);
+  m_universeClient = std::move(universeClient);
 }
 
 void MainMixer::setWorldPainter(WorldPainterPtr worldPainter) {
-  m_worldPainter = move(worldPainter);
+  m_worldPainter = std::move(worldPainter);
 }
 
 void MainMixer::update(float dt, bool muteSfx, bool muteMusic) {
diff --git a/source/frontend/StarMerchantInterface.cpp b/source/frontend/StarMerchantInterface.cpp
index 17f4995..ec17391 100644
--- a/source/frontend/StarMerchantInterface.cpp
+++ b/source/frontend/StarMerchantInterface.cpp
@@ -23,8 +23,8 @@ namespace Star {
 
 MerchantPane::MerchantPane(
     WorldClientPtr worldClient, PlayerPtr player, Json const& settings, EntityId sourceEntityId) {
-  m_worldClient = move(worldClient);
-  m_player = move(player);
+  m_worldClient = std::move(worldClient);
+  m_player = std::move(player);
   m_sourceEntityId = sourceEntityId;
 
   auto assets = Root::singleton().assets();
diff --git a/source/frontend/StarNameplatePainter.cpp b/source/frontend/StarNameplatePainter.cpp
index fe9d829..4637232 100644
--- a/source/frontend/StarNameplatePainter.cpp
+++ b/source/frontend/StarNameplatePainter.cpp
@@ -44,7 +44,7 @@ void NameplatePainter::update(float dt, WorldClientPtr const& world, WorldCamera
     if (!m_entitiesWithNametags.contains(entity->entityId())) {
       Nametag nametag = {entity->name(), entity->statusText(), entity->nametagColor(), 1.0f, entity->entityId()};
       RectF boundBox = determineBoundBox(Vec2F(), nametag);
-      m_nametags.addBubble(Vec2F(), boundBox, move(nametag));
+      m_nametags.addBubble(Vec2F(), boundBox, std::move(nametag));
     }
   }
 
@@ -69,7 +69,7 @@ void NameplatePainter::update(float dt, WorldClientPtr const& world, WorldCamera
     }
   });
 
-  m_entitiesWithNametags = move(foundEntities);
+  m_entitiesWithNametags = std::move(foundEntities);
   m_nametags.update(dt);
 }
 
diff --git a/source/frontend/StarQuestInterface.cpp b/source/frontend/StarQuestInterface.cpp
index d9f0b1b..b862b31 100644
--- a/source/frontend/StarQuestInterface.cpp
+++ b/source/frontend/StarQuestInterface.cpp
@@ -287,7 +287,7 @@ void QuestLogInterface::showQuests(List<QuestPtr> quests) {
   verticalLayout->update(0);
 }
 
-QuestPane::QuestPane(QuestPtr const& quest, PlayerPtr player) : Pane(), m_quest(quest), m_player(move(player)) {}
+QuestPane::QuestPane(QuestPtr const& quest, PlayerPtr player) : Pane(), m_quest(quest), m_player(std::move(player)) {}
 
 void QuestPane::commonSetup(Json config, String bodyText, String const& portraitName) {
   GuiReader reader;
@@ -348,7 +348,7 @@ PanePtr QuestPane::createTooltip(Vec2I const& screenPosition) {
 }
 
 NewQuestInterface::NewQuestInterface(QuestManagerPtr const& manager, QuestPtr const& quest, PlayerPtr player)
-  : QuestPane(quest, move(player)), m_manager(manager), m_declined(false) {
+  : QuestPane(quest, std::move(player)), m_manager(manager), m_declined(false) {
   auto assets = Root::singleton().assets();
 
   List<Drawable> objectivePortrait = m_quest->portrait("Objective").value({});
@@ -436,7 +436,7 @@ void QuestCompleteInterface::close() {
   dismiss();
 }
 
-QuestFailedInterface::QuestFailedInterface(QuestPtr const& quest, PlayerPtr player) : QuestPane(quest, move(player)) {
+QuestFailedInterface::QuestFailedInterface(QuestPtr const& quest, PlayerPtr player) : QuestPane(quest, std::move(player)) {
   auto assets = Root::singleton().assets();
   String configFile = m_quest->getTemplate()->questFailedGuiConfig.value(assets->json("/quests/quests.config:defaultGuiConfigs.questFailed").toString());
   Json config = assets->json(configFile);
diff --git a/source/frontend/StarScriptPane.cpp b/source/frontend/StarScriptPane.cpp
index 2105680..c98bd2c 100644
--- a/source/frontend/StarScriptPane.cpp
+++ b/source/frontend/StarScriptPane.cpp
@@ -25,7 +25,7 @@ ScriptPane::ScriptPane(UniverseClientPtr client, Json config, EntityId sourceEnt
   auto& root = Root::singleton();
   auto assets = root.assets();
 
-  m_client = move(client);
+  m_client = std::move(client);
   m_sourceEntityId = sourceEntityId;
 
   m_script.addCallbacks("player", LuaBindings::makePlayerCallbacks(m_client->mainPlayer().get()));
diff --git a/source/frontend/StarSongbookInterface.cpp b/source/frontend/StarSongbookInterface.cpp
index 4848f4e..8ccb437 100644
--- a/source/frontend/StarSongbookInterface.cpp
+++ b/source/frontend/StarSongbookInterface.cpp
@@ -10,7 +10,7 @@
 namespace Star {
 
 SongbookInterface::SongbookInterface(PlayerPtr player) {
-  m_player = move(player);
+  m_player = std::move(player);
 
   auto assets = Root::singleton().assets();
 
diff --git a/source/frontend/StarTeamBar.cpp b/source/frontend/StarTeamBar.cpp
index f34961b..d0c23c5 100644
--- a/source/frontend/StarTeamBar.cpp
+++ b/source/frontend/StarTeamBar.cpp
@@ -195,7 +195,7 @@ void TeamBar::buildTeamBar() {
 
     List<Drawable> drawables = member.portrait;
     Drawable::scaleAll(drawables, portraitScale);
-    cell->fetchChild<ImageWidget>("portrait")->setDrawables(move(drawables));
+    cell->fetchChild<ImageWidget>("portrait")->setDrawables(std::move(drawables));
 
     if (member.world == m_client->playerWorld() && m_client->worldClient()) {
       auto mpos = member.position;
diff --git a/source/frontend/StarTitleScreen.cpp b/source/frontend/StarTitleScreen.cpp
index f9f16bd..895e88a 100644
--- a/source/frontend/StarTitleScreen.cpp
+++ b/source/frontend/StarTitleScreen.cpp
@@ -50,7 +50,7 @@ TitleScreen::TitleScreen(PlayerStoragePtr playerStorage, MixerPtr mixer)
 }
 
 void TitleScreen::renderInit(RendererPtr renderer) {
-  m_renderer = move(renderer);
+  m_renderer = std::move(renderer);
   m_environmentPainter = make_shared<EnvironmentPainter>(m_renderer);
 }
 
@@ -181,7 +181,7 @@ String TitleScreen::multiPlayerAddress() const {
 
 void TitleScreen::setMultiPlayerAddress(String address) {
   m_multiPlayerMenu->fetchChild<TextBoxWidget>("address")->setText(address);
-  m_connectionAddress = move(address);
+  m_connectionAddress = std::move(address);
 }
 
 String TitleScreen::multiPlayerPort() const {
@@ -190,7 +190,7 @@ String TitleScreen::multiPlayerPort() const {
 
 void TitleScreen::setMultiPlayerPort(String port) {
   m_multiPlayerMenu->fetchChild<TextBoxWidget>("port")->setText(port);
-  m_connectionPort = move(port);
+  m_connectionPort = std::move(port);
 }
 
 String TitleScreen::multiPlayerAccount() const {
@@ -199,7 +199,7 @@ String TitleScreen::multiPlayerAccount() const {
 
 void TitleScreen::setMultiPlayerAccount(String account) {
   m_multiPlayerMenu->fetchChild<TextBoxWidget>("account")->setText(account);
-  m_account = move(account);
+  m_account = std::move(account);
 }
 
 String TitleScreen::multiPlayerPassword() const {
@@ -208,7 +208,7 @@ String TitleScreen::multiPlayerPassword() const {
 
 void TitleScreen::setMultiPlayerPassword(String password) {
   m_multiPlayerMenu->fetchChild<TextBoxWidget>("password")->setText(password);
-  m_password = move(password);
+  m_password = std::move(password);
 }
 
 void TitleScreen::initMainMenu() {
diff --git a/source/frontend/StarVoice.cpp b/source/frontend/StarVoice.cpp
index 68b83ae..fc1c5a9 100644
--- a/source/frontend/StarVoice.cpp
+++ b/source/frontend/StarVoice.cpp
@@ -61,7 +61,8 @@ float getAudioLoudness(int16_t* data, size_t samples, float volume = 1.0f) {
 	return highest;
 }
 
-struct VoiceAudioStream {
+class VoiceAudioStream {
+public:
   // TODO: This should really be a ring buffer instead.
   std::queue<int16_t> samples;
 	SDL_AudioStream* sdlAudioStreamMono;
@@ -173,7 +174,7 @@ template <typename T>
 inline bool change(T& value, T newValue, bool& out) {
 	bool changed = value != newValue;
 	out |= changed;
-	value = move(newValue);
+	value = std::move(newValue);
 	return changed;
 }
 
@@ -480,7 +481,7 @@ int Voice::send(DataStreamBuffer& out, size_t budget) {
 	if (m_encodedChunks.empty())
 		return 0;
 
-	std::vector<ByteArray> encodedChunks = move(m_encodedChunks);
+	std::vector<ByteArray> encodedChunks = std::move(m_encodedChunks);
 	size_t encodedChunksLength = m_encodedChunksLength;
 	m_encodedChunksLength = 0;
 
@@ -692,7 +693,7 @@ void Voice::thread() {
 
 					{
 						MutexLocker lock(m_encodeMutex);
-						m_encodedChunks.emplace_back(move(encoded));
+						m_encodedChunks.emplace_back(std::move(encoded));
 						m_encodedChunksLength += encodedSize;
 
 						encoded = ByteArray(VOICE_MAX_PACKET_SIZE, 0);
diff --git a/source/game/StarActorMovementController.cpp b/source/game/StarActorMovementController.cpp
index 4f574c4..00e3726 100644
--- a/source/game/StarActorMovementController.cpp
+++ b/source/game/StarActorMovementController.cpp
@@ -1104,7 +1104,7 @@ void ActorMovementController::doSetAnchorState(Maybe<EntityAnchorState> anchorSt
   }
 
   m_anchorState.set(anchorState);
-  m_entityAnchor = move(entityAnchor);
+  m_entityAnchor = std::move(entityAnchor);
 
   if (m_entityAnchor)
     setPosition(m_entityAnchor->position);
diff --git a/source/game/StarAmbient.cpp b/source/game/StarAmbient.cpp
index 7209ca8..52d47d6 100644
--- a/source/game/StarAmbient.cpp
+++ b/source/game/StarAmbient.cpp
@@ -13,7 +13,7 @@ AmbientTrackGroup::AmbientTrackGroup() {
   tracks = {};
 }
 
-AmbientTrackGroup::AmbientTrackGroup(StringList tracks) : tracks(move(tracks)) {}
+AmbientTrackGroup::AmbientTrackGroup(StringList tracks) : tracks(std::move(tracks)) {}
 
 AmbientTrackGroup::AmbientTrackGroup(Json const& config, String const& directory) {
   for (auto track : jsonToStringList(config.get("tracks", JsonArray())))
@@ -27,7 +27,7 @@ Json AmbientTrackGroup::toJson() const {
 AmbientNoisesDescription::AmbientNoisesDescription() {}
 
 AmbientNoisesDescription::AmbientNoisesDescription(AmbientTrackGroup day, AmbientTrackGroup night)
-  : daySounds(move(day)), nightSounds(move(night)) {}
+  : daySounds(std::move(day)), nightSounds(std::move(night)) {}
 
 AmbientNoisesDescription::AmbientNoisesDescription(Json const& config, String const& directory) {
   if (auto day = config.opt("day"))
diff --git a/source/game/StarAnimation.cpp b/source/game/StarAnimation.cpp
index 8a1e9c1..9cbf88a 100644
--- a/source/game/StarAnimation.cpp
+++ b/source/game/StarAnimation.cpp
@@ -44,7 +44,7 @@ void Animation::setAngle(float angle) {
 }
 
 void Animation::setProcessing(DirectivesGroup processing) {
-  m_processing = move(processing);
+  m_processing = std::move(processing);
 }
 
 void Animation::setColor(Color color) {
@@ -52,7 +52,7 @@ void Animation::setColor(Color color) {
 }
 
 void Animation::setTag(String tagName, String tagValue) {
-  m_tagValues[move(tagName)] = move(tagValue);
+  m_tagValues[std::move(tagName)] = std::move(tagValue);
 }
 
 void Animation::clearTags() {
@@ -69,7 +69,7 @@ Drawable Animation::drawable(float pixelSize) const {
   if (m_appendFrame)
     baseFrame += ":" + toString(m_frame);
 
-  Drawable drawable = Drawable::makeImage(move(baseFrame), pixelSize, m_centered, m_offset);
+  Drawable drawable = Drawable::makeImage(std::move(baseFrame), pixelSize, m_centered, m_offset);
   drawable.imagePart().addDirectivesGroup(m_processing);
   drawable.rotate(m_angle);
   drawable.color = m_color;
diff --git a/source/game/StarBehaviorDatabase.cpp b/source/game/StarBehaviorDatabase.cpp
index 5e08d98..03017ca 100644
--- a/source/game/StarBehaviorDatabase.cpp
+++ b/source/game/StarBehaviorDatabase.cpp
@@ -124,7 +124,7 @@ void parseNodeParameters(JsonObject& parameters) {
 }
 
 ActionNode::ActionNode(String name, StringMap<NodeParameter> parameters, StringMap<NodeOutput> output)
-  : name(move(name)), parameters(move(parameters)), output(move(output)) { }
+  : name(std::move(name)), parameters(std::move(parameters)), output(std::move(output)) { }
 
 DecoratorNode::DecoratorNode(String const& name, StringMap<NodeParameter> parameters, BehaviorNodeConstPtr child)
   : name(name), parameters(parameters), child(child) { }
@@ -214,7 +214,7 @@ BehaviorTreeConstPtr BehaviorDatabase::buildTree(Json const& config, StringMap<N
     parameters.set(p.first, p.second);
   BehaviorNodeConstPtr root = behaviorNode(config.get("root"), parameters, tree);
   tree.root = root;
-  return make_shared<BehaviorTree>(move(tree));
+  return std::make_shared<BehaviorTree>(std::move(tree));
 }
 
 Json BehaviorDatabase::behaviorConfig(String const& name) const {
diff --git a/source/game/StarBehaviorState.cpp b/source/game/StarBehaviorState.cpp
index 39a800e..c6001af 100644
--- a/source/game/StarBehaviorState.cpp
+++ b/source/game/StarBehaviorState.cpp
@@ -17,7 +17,7 @@ List<NodeParameterType> BlackboardTypes = {
   NodeParameterType::String
 };
 
-Blackboard::Blackboard(LuaTable luaContext) : m_luaContext(move(luaContext)) {
+Blackboard::Blackboard(LuaTable luaContext) : m_luaContext(std::move(luaContext)) {
   for (auto type : BlackboardTypes) {
     m_board.set(type, {});
     m_input.set(type, {});
@@ -118,20 +118,20 @@ void Blackboard::clearEphemerals(Set<pair<NodeParameterType, String>> ephemerals
   }
 }
 
-DecoratorState::DecoratorState(LuaThread thread) : thread(move(thread)) {
-  child = make_shared<NodeState>();
+DecoratorState::DecoratorState(LuaThread thread) : thread(std::move(thread)) {
+  child = std::make_shared<NodeState>();
 }
 
 CompositeState::CompositeState(size_t childCount) : index() {
   for (size_t i = 0; i < childCount; i++)
-    children.append(make_shared<NodeState>());
+    children.append(std::make_shared<NodeState>());
 }
 
 CompositeState::CompositeState(size_t childCount, size_t begin) : CompositeState(childCount) {
   index = begin;
 }
 
-BehaviorState::BehaviorState(BehaviorTreeConstPtr tree, LuaTable context, Maybe<BlackboardWeakPtr> blackboard) : m_tree(tree), m_luaContext(move(context)) {
+BehaviorState::BehaviorState(BehaviorTreeConstPtr tree, LuaTable context, Maybe<BlackboardWeakPtr> blackboard) : m_tree(tree), m_luaContext(std::move(context)) {
   if (blackboard)
     m_board = *blackboard;
   else
diff --git a/source/game/StarBiomePlacement.cpp b/source/game/StarBiomePlacement.cpp
index a7c2802..0017cde 100644
--- a/source/game/StarBiomePlacement.cpp
+++ b/source/game/StarBiomePlacement.cpp
@@ -55,7 +55,7 @@ EnumMap<BiomePlacementMode> const BiomePlacementModeNames{
 };
 
 BiomeItemPlacement::BiomeItemPlacement(BiomeItem item, Vec2I position, float priority)
-  : item(move(item)), position(position), priority(priority) {}
+  : item(std::move(item)), position(position), priority(priority) {}
 
 bool BiomeItemPlacement::operator<(BiomeItemPlacement const& rhs) const {
   return priority < rhs.priority;
diff --git a/source/game/StarCelestialCoordinate.cpp b/source/game/StarCelestialCoordinate.cpp
index 70bd61d..0c3e914 100644
--- a/source/game/StarCelestialCoordinate.cpp
+++ b/source/game/StarCelestialCoordinate.cpp
@@ -10,7 +10,7 @@ namespace Star {
 CelestialCoordinate::CelestialCoordinate() : m_planetaryOrbitNumber(0), m_satelliteOrbitNumber(0) {}
 
 CelestialCoordinate::CelestialCoordinate(Vec3I location, int planetaryOrbitNumber, int satelliteOrbitNumber)
-  : m_location(move(location)),
+  : m_location(std::move(location)),
     m_planetaryOrbitNumber(planetaryOrbitNumber),
     m_satelliteOrbitNumber(satelliteOrbitNumber) {}
 
diff --git a/source/game/StarCelestialDatabase.cpp b/source/game/StarCelestialDatabase.cpp
index dd0bc51..c1b9a7f 100644
--- a/source/game/StarCelestialDatabase.cpp
+++ b/source/game/StarCelestialDatabase.cpp
@@ -160,11 +160,11 @@ CelestialResponse CelestialMasterDatabase::respondToRequest(CelestialRequest con
     auto chunk = getChunk(*chunkLocation);
     // System objects are sent by separate system requests.
     chunk.systemObjects.clear();
-    return makeLeft(move(chunk));
+    return makeLeft(std::move(chunk));
   } else if (auto systemLocation = request.maybeRight()) {
     auto const& chunk = getChunk(chunkIndexFor(*systemLocation));
     CelestialSystemObjects systemObjects = {*systemLocation, chunk.systemObjects.get(*systemLocation)};
-    return makeRight(move(systemObjects));
+    return makeRight(std::move(systemObjects));
   } else {
     return CelestialResponse();
   }
@@ -435,7 +435,7 @@ CelestialChunk CelestialMasterDatabase::produceChunk(Vec2I const& chunkIndex) co
   for (auto const& systemLocation : systemLocations) {
     if (auto systemInformation = produceSystem(random, systemLocation)) {
       chunkData.systemParameters[systemLocation] = systemInformation.get().first;
-      chunkData.systemObjects[systemLocation] = move(systemInformation.get().second);
+      chunkData.systemObjects[systemLocation] = std::move(systemInformation.get().second);
 
       if (systemInformation.get().first.getParameter("magnitude").toFloat()
           >= m_generationInformation.minimumConstellationMagnitude)
@@ -527,11 +527,11 @@ Maybe<pair<CelestialParameters, HashMap<int, CelestialPlanet>>> CelestialMasterD
         }
       }
 
-      systemObjects[planetPair.first] = move(planet);
+      systemObjects[planetPair.first] = std::move(planet);
     }
   }
 
-  return pair<CelestialParameters, HashMap<int, CelestialPlanet>>{move(systemParameters), move(systemObjects)};
+  return pair<CelestialParameters, HashMap<int, CelestialPlanet>>{std::move(systemParameters), std::move(systemObjects)};
 }
 
 List<CelestialConstellation> CelestialMasterDatabase::produceConstellations(
@@ -619,7 +619,7 @@ List<CelestialConstellation> CelestialMasterDatabase::produceConstellations(
 CelestialSlaveDatabase::CelestialSlaveDatabase(CelestialBaseInformation baseInformation) {
   auto config = Root::singleton().assets()->json("/celestial.config");
 
-  m_baseInformation = move(baseInformation);
+  m_baseInformation = std::move(baseInformation);
   m_requestTimeout = config.getFloat("requestTimeout");
 }
 
@@ -679,12 +679,12 @@ void CelestialSlaveDatabase::pushResponses(List<CelestialResponse> responses) {
   for (auto& response : responses) {
     if (auto celestialChunk = response.leftPtr()) {
       m_pendingChunkRequests.remove(celestialChunk->chunkIndex);
-      m_chunkCache.set(celestialChunk->chunkIndex, move(*celestialChunk));
+      m_chunkCache.set(celestialChunk->chunkIndex, std::move(*celestialChunk));
     } else if (auto celestialSystemObjects = response.rightPtr()) {
       m_pendingSystemRequests.remove(celestialSystemObjects->systemLocation);
       auto chunkLocation = chunkIndexFor(celestialSystemObjects->systemLocation);
       if (auto chunk = m_chunkCache.ptr(chunkLocation))
-        chunk->systemObjects[celestialSystemObjects->systemLocation] = move(celestialSystemObjects->planets);
+        chunk->systemObjects[celestialSystemObjects->systemLocation] = std::move(celestialSystemObjects->planets);
     }
   }
 }
diff --git a/source/game/StarCelestialGraphics.cpp b/source/game/StarCelestialGraphics.cpp
index e1a5aa8..4233635 100644
--- a/source/game/StarCelestialGraphics.cpp
+++ b/source/game/StarCelestialGraphics.cpp
@@ -52,12 +52,12 @@ List<pair<String, float>> CelestialGraphics::drawWorld(
     // base layer, otherwise use the bottom most mask image.
     if (terrestrialParameters->primarySurfaceLiquid != EmptyLiquidId && !liquidImages.empty()) {
       String liquidBaseImage = liquidImages.replace("<liquid>", liquidsDatabase->liquidName(terrestrialParameters->primarySurfaceLiquid));
-      layers.append({move(liquidBaseImage), imageScale});
+      layers.append({std::move(liquidBaseImage), imageScale});
     } else {
       if (baseCount > 0) {
         String baseLayer = strf("{}?hueshift={}", baseImages.replace("<biome>",
             terrestrialParameters->primaryBiome).replace("<num>", toString(baseCount)), terrestrialParameters->hueShift);
-        layers.append({move(baseLayer), imageScale});
+        layers.append({std::move(baseLayer), imageScale});
       }
     }
 
@@ -70,12 +70,12 @@ List<pair<String, float>> CelestialGraphics::drawWorld(
       if (terrestrialParameters->hueShift != 0)
         hueShiftString = strf("?hueshift={}", terrestrialParameters->hueShift);
       String layer = baseImage + hueShiftString + dynamicMaskString;
-      layers.append({move(layer), imageScale});
+      layers.append({std::move(layer), imageScale});
     }
 
     if (!shadowImages.empty()) {
       String shadow = shadowImages.replace("<num>", toString(shadowParameters.randomizeParameterRange(gfxConfig.getArray("shadowNumber")).toInt()));
-      layers.append({move(shadow), imageScale});
+      layers.append({std::move(shadow), imageScale});
     }
 
   } else if (type == "Asteroids") {
@@ -88,18 +88,18 @@ List<pair<String, float>> CelestialGraphics::drawWorld(
       String biomeMaskBase = maskImages.replace("<num>", toString(maskCount - i));
       String dynamicMask = dynamicsImages.replace("<num>", toString(celestialParameters.randomizeParameterRange("dynamicsRange", i).toInt()));
       String layer = strf("{}?addmask={}", biomeMaskBase, dynamicMask);
-      layers.append({move(layer), imageScale});
+      layers.append({std::move(layer), imageScale});
     }
 
   } else if (type == "FloatingDungeon") {
     String image = celestialParameters.getParameter("image").toString();
     float imageScale = celestialParameters.getParameter("imageScale", 1.0f).toFloat();
-    layers.append({move(image), imageScale});
+    layers.append({std::move(image), imageScale});
 
     if (!celestialParameters.getParameter("dynamicsImages").toString().empty()) {
       String dynamicsImages = celestialParameters.getParameter("dynamicsImages", "").toString();
       String dynamicsImage = dynamicsImages.replace("<num>", toString(celestialParameters.randomizeParameterRange("dynamicsRange").toInt()));
-      layers.append({move(dynamicsImage), imageScale});
+      layers.append({std::move(dynamicsImage), imageScale});
     }
 
   } else if (type == "GasGiant") {
@@ -127,7 +127,7 @@ List<pair<String, float>> CelestialGraphics::drawWorld(
 
     if (!shadowImages.empty()) {
       String shadow = shadowImages.replace("<num>", toString(shadowParameters.randomizeParameterRange(gfxConfig.getArray("shadowNumber")).toInt()));
-      layers.append({move(shadow), imageScale});
+      layers.append({std::move(shadow), imageScale});
     }
   }
 
@@ -247,7 +247,7 @@ List<pair<String, float>> CelestialGraphics::drawSystemTwinkle(CelestialDatabase
 
   String twinkleFrame = strf("{}:{}", twinkleFrameset, (int)(std::fmod<double>(time / twinkleTime, 1.0f) * twinkleFrameCount));
 
-  return {{move(twinkleBackground), 1.0f}, {move(twinkleFrame), twinkleScale}};
+  return {{std::move(twinkleBackground), 1.0f}, {std::move(twinkleFrame), twinkleScale}};
 }
 
 List<pair<String, float>> CelestialGraphics::drawSystemPlanetaryObject(CelestialDatabasePtr celestialDatabase, CelestialCoordinate const& coordinate) {
diff --git a/source/game/StarCelestialParameters.cpp b/source/game/StarCelestialParameters.cpp
index 9f94c4c..183b270 100644
--- a/source/game/StarCelestialParameters.cpp
+++ b/source/game/StarCelestialParameters.cpp
@@ -12,7 +12,7 @@ namespace Star {
 CelestialParameters::CelestialParameters() : m_seed(0) {}
 
 CelestialParameters::CelestialParameters(CelestialCoordinate coordinate, uint64_t seed, String name, Json parameters)
-  : m_coordinate(move(coordinate)), m_seed(seed), m_name(move(name)), m_parameters(move(parameters)) {
+  : m_coordinate(std::move(coordinate)), m_seed(seed), m_name(std::move(name)), m_parameters(std::move(parameters)) {
   if (auto worldType = getParameter("worldType").optString()) {
     if (worldType->equalsIgnoreCase("Terrestrial")) {
       auto worldSize = getParameter("worldSize").toString();
@@ -27,7 +27,7 @@ CelestialParameters::CelestialParameters(CelestialCoordinate coordinate, uint64_
 }
 
 CelestialParameters::CelestialParameters(ByteArray netStore) {
-  DataStreamBuffer ds(move(netStore));
+  DataStreamBuffer ds(std::move(netStore));
   ds >> m_coordinate;
   ds >> m_seed;
   ds >> m_name;
@@ -79,7 +79,7 @@ Json CelestialParameters::parameters() const {
 }
 
 Json CelestialParameters::getParameter(String const& name, Json def) const {
-  return m_parameters.get(name, move(def));
+  return m_parameters.get(name, std::move(def));
 }
 
 Json CelestialParameters::randomizeParameterList(String const& name, int32_t mix) const {
diff --git a/source/game/StarCelestialTypes.cpp b/source/game/StarCelestialTypes.cpp
index 1cb1d79..fa782e2 100644
--- a/source/game/StarCelestialTypes.cpp
+++ b/source/game/StarCelestialTypes.cpp
@@ -49,7 +49,7 @@ CelestialChunk::CelestialChunk(Json const& store) {
     CelestialConstellation constellation;
     for (auto const& l : lines.toArray())
       constellation.append({jsonToVec2I(l.get(0)), jsonToVec2I(l.get(1))});
-    constellations.append(move(constellation));
+    constellations.append(std::move(constellation));
   }
 
   for (auto const& p : store.getArray("systemParameters"))
@@ -62,10 +62,10 @@ CelestialChunk::CelestialChunk(Json const& store) {
       planet.planetParameters = CelestialParameters(planetPair.get(1).get("parameters"));
       for (auto const& satellitePair : planetPair.get(1).getArray("satellites"))
         planet.satelliteParameters.add(satellitePair.getInt(0), CelestialParameters(satellitePair.get(1)));
-      celestialSystemObjects.add(planetPair.getInt(0), move(planet));
+      celestialSystemObjects.add(planetPair.getInt(0), std::move(planet));
     }
 
-    systemObjects[jsonToVec3I(p.get(0))] = move(celestialSystemObjects);
+    systemObjects[jsonToVec3I(p.get(0))] = std::move(celestialSystemObjects);
   }
 }
 
@@ -92,9 +92,9 @@ Json CelestialChunk::toJson() const {
 
       planetsStore.append(JsonArray{planetPair.first,
           JsonObject{
-              {"parameters", planetPair.second.planetParameters.diskStore()}, {"satellites", move(satellitesStore)}}});
+              {"parameters", planetPair.second.planetParameters.diskStore()}, {"satellites", std::move(satellitesStore)}}});
     }
-    systemObjectsStore.append(JsonArray{jsonFromVec3I(systemObjectPair.first), move(planetsStore)});
+    systemObjectsStore.append(JsonArray{jsonFromVec3I(systemObjectPair.first), std::move(planetsStore)});
   }
 
   return JsonObject{{"chunkIndex", jsonFromVec2I(chunkIndex)},
diff --git a/source/game/StarClientContext.cpp b/source/game/StarClientContext.cpp
index 748b864..e6fd89a 100644
--- a/source/game/StarClientContext.cpp
+++ b/source/game/StarClientContext.cpp
@@ -25,9 +25,9 @@ DataStream& operator<<(DataStream& ds, ShipUpgrades const& upgrades) {
 }
 
 ClientContext::ClientContext(Uuid serverUuid, Uuid playerUuid) {
-  m_serverUuid = move(serverUuid);
-  m_playerUuid = move(playerUuid);
-  m_rpc = make_shared<JsonRpc>();
+  m_serverUuid = std::move(serverUuid);
+  m_playerUuid = std::move(playerUuid);
+  m_rpc = std::make_shared<JsonRpc>();
 
   m_netGroup.addNetElement(&m_orbitWarpActionNetState);
   m_netGroup.addNetElement(&m_playerWorldIdNetState);
@@ -81,13 +81,13 @@ void ClientContext::readUpdate(ByteArray data) {
   if (data.empty())
     return;
 
-  DataStreamBuffer ds(move(data));
+  DataStreamBuffer ds(std::move(data));
 
   m_rpc->receive(ds.read<ByteArray>());
 
   auto shipUpdates = ds.read<ByteArray>();
   if (!shipUpdates.empty())
-    m_newShipUpdates.merge(DataStreamBuffer::deserialize<WorldChunks>(move(shipUpdates)), true);
+    m_newShipUpdates.merge(DataStreamBuffer::deserialize<WorldChunks>(std::move(shipUpdates)), true);
 
   m_netGroup.readNetState(ds.read<ByteArray>());
 }
diff --git a/source/game/StarCollisionGenerator.cpp b/source/game/StarCollisionGenerator.cpp
index d7606dd..d9e7af7 100644
--- a/source/game/StarCollisionGenerator.cpp
+++ b/source/game/StarCollisionGenerator.cpp
@@ -33,9 +33,9 @@ void CollisionGenerator::getBlocksPlatforms(List<CollisionBlock>& list, RectI co
           CollisionBlock block;
           block.space = Vec2I(x, y);
           block.kind = kind;
-          block.poly = PolyF(move(vertices));
+          block.poly = PolyF(std::move(vertices));
           block.polyBounds = block.poly.boundBox();
-          list.append(move(block));
+          list.append(std::move(block));
         };
 
         // This was once simple and elegant and made sense but then I made it
@@ -151,7 +151,7 @@ void CollisionGenerator::getBlocksMarchingSquares(List<CollisionBlock>& list, Re
     }
     block.polyBounds = block.poly.boundBox();
     block.kind = std::max({collisionKind(x, y), collisionKind(x + 1, y), collisionKind(x, y + 1), collisionKind(x + 1, y + 1)});
-    list.append(move(block));
+    list.append(std::move(block));
   };
 
   int xMin = region.xMin();
diff --git a/source/game/StarCommandProcessor.cpp b/source/game/StarCommandProcessor.cpp
index 4775a1e..02a8ec0 100644
--- a/source/game/StarCommandProcessor.cpp
+++ b/source/game/StarCommandProcessor.cpp
@@ -440,7 +440,7 @@ String CommandProcessor::spawnVehicle(ConnectionId connectionId, String const& a
     bool done = m_universe->executeForClient(connectionId,
         [&](WorldServer* world, PlayerPtr const& player) {
           vehicle->setPosition(player->aimPosition());
-          world->addEntity(move(vehicle));
+          world->addEntity(std::move(vehicle));
         });
 
     return done ? "" : "Invalid client state";
diff --git a/source/game/StarDamage.cpp b/source/game/StarDamage.cpp
index 83c88ce..cbfab6f 100644
--- a/source/game/StarDamage.cpp
+++ b/source/game/StarDamage.cpp
@@ -61,18 +61,18 @@ DamageSource::DamageSource(DamageType damageType,
     List<EphemeralStatusEffect> statusEffects,
     Knockback knockback,
     bool rayCheck)
-  : damageType(move(damageType)),
-    damageArea(move(damageArea)),
-    damage(move(damage)),
-    trackSourceEntity(move(trackSourceEntity)),
-    sourceEntityId(move(sourceEntityId)),
-    team(move(team)),
-    damageRepeatGroup(move(damageRepeatGroup)),
-    damageRepeatTimeout(move(damageRepeatTimeout)),
-    damageSourceKind(move(damageSourceKind)),
-    statusEffects(move(statusEffects)),
-    knockback(move(knockback)),
-    rayCheck(move(rayCheck)) {}
+  : damageType(std::move(damageType)),
+    damageArea(std::move(damageArea)),
+    damage(std::move(damage)),
+    trackSourceEntity(std::move(trackSourceEntity)),
+    sourceEntityId(std::move(sourceEntityId)),
+    team(std::move(team)),
+    damageRepeatGroup(std::move(damageRepeatGroup)),
+    damageRepeatTimeout(std::move(damageRepeatTimeout)),
+    damageSourceKind(std::move(damageSourceKind)),
+    statusEffects(std::move(statusEffects)),
+    knockback(std::move(knockback)),
+    rayCheck(std::move(rayCheck)) {}
 
 Json DamageSource::toJson() const {
   Json damageAreaJson;
@@ -266,8 +266,8 @@ DamageNotification::DamageNotification(EntityId sourceEntityId,
     damageDealt(damageDealt),
     healthLost(healthLost),
     hitType(hitType),
-    damageSourceKind(move(damageSourceKind)),
-    targetMaterialKind(move(targetMaterialKind)) {}
+    damageSourceKind(std::move(damageSourceKind)),
+    targetMaterialKind(std::move(targetMaterialKind)) {}
 
 Json DamageNotification::toJson() const {
   return JsonObject{{"sourceEntityId", sourceEntityId},
diff --git a/source/game/StarDamageDatabase.cpp b/source/game/StarDamageDatabase.cpp
index 9982a35..8248295 100644
--- a/source/game/StarDamageDatabase.cpp
+++ b/source/game/StarDamageDatabase.cpp
@@ -15,7 +15,7 @@ DamageDatabase::DamageDatabase() {
     for (auto particle : p.second.getObject("damageNumberParticles")) {
       type.damageNumberParticles.set(HitTypeNames.getLeft(particle.first), particle.second.toString());
     }
-    m_elementalTypes.set(p.first, move(type));
+    m_elementalTypes.set(p.first, std::move(type));
   }
 
   auto files = assets->scanExtension("damage");
@@ -43,7 +43,7 @@ DamageDatabase::DamageDatabase() {
     if (!m_elementalTypes.contains(kind.elementalType))
       throw StarException(strf("Undefined elemental type {} in damage kind {}", kind.elementalType, name));
 
-    m_damageKinds.set(name, move(kind));
+    m_damageKinds.set(name, std::move(kind));
   }
 }
 
diff --git a/source/game/StarDamageManager.cpp b/source/game/StarDamageManager.cpp
index 8c95a4f..dadaafb 100644
--- a/source/game/StarDamageManager.cpp
+++ b/source/game/StarDamageManager.cpp
@@ -117,7 +117,7 @@ void DamageManager::update(float dt) {
           addHitRequest({causingEntity->entityId(), targetEntity->entityId(), damageRequest});
 
           if (damageSource.damageType != NoDamage)
-            addDamageRequest({causingEntity->entityId(), targetEntity->entityId(), move(damageRequest)});
+            addDamageRequest({causingEntity->entityId(), targetEntity->entityId(), std::move(damageRequest)});
         }
       }
     }
@@ -144,7 +144,7 @@ void DamageManager::pushRemoteDamageRequest(RemoteDamageRequest const& remoteDam
   if (auto targetEntity = m_world->entity(remoteDamageRequest.targetEntityId)) {
     starAssert(targetEntity->isMaster());
     for (auto& damageNotification : targetEntity->applyDamage(remoteDamageRequest.damageRequest))
-      addDamageNotification({remoteDamageRequest.damageRequest.sourceEntityId, move(damageNotification)});
+      addDamageNotification({remoteDamageRequest.damageRequest.sourceEntityId, std::move(damageNotification)});
   }
 }
 
@@ -155,7 +155,7 @@ void DamageManager::pushRemoteDamageNotification(RemoteDamageNotification remote
       sourceEntity->damagedOther(remoteDamageNotification.damageNotification);
   }
 
-  m_pendingNotifications.append(move(remoteDamageNotification.damageNotification));
+  m_pendingNotifications.append(std::move(remoteDamageNotification.damageNotification));
 }
 
 List<RemoteHitRequest> DamageManager::pullRemoteHitRequests() {
@@ -251,14 +251,14 @@ void DamageManager::addHitRequest(RemoteHitRequest const& remoteHitRequest) {
 
 void DamageManager::addDamageRequest(RemoteDamageRequest remoteDamageRequest) {
   if (remoteDamageRequest.destinationConnection() == m_connectionId)
-    pushRemoteDamageRequest(move(remoteDamageRequest));
+    pushRemoteDamageRequest(std::move(remoteDamageRequest));
   else
-    m_pendingRemoteDamageRequests.append(move(remoteDamageRequest));
+    m_pendingRemoteDamageRequests.append(std::move(remoteDamageRequest));
 }
 
 void DamageManager::addDamageNotification(RemoteDamageNotification remoteDamageNotification) {
   pushRemoteDamageNotification(remoteDamageNotification);
-  m_pendingRemoteNotifications.append(move(remoteDamageNotification));
+  m_pendingRemoteNotifications.append(std::move(remoteDamageNotification));
 }
 
 }
diff --git a/source/game/StarDrawable.cpp b/source/game/StarDrawable.cpp
index 08c14be..2c527a5 100644
--- a/source/game/StarDrawable.cpp
+++ b/source/game/StarDrawable.cpp
@@ -70,7 +70,7 @@ Drawable::ImagePart& Drawable::ImagePart::removeDirectives(bool keepImageCenterP
 
 Drawable Drawable::makeLine(Line2F const& line, float lineWidth, Color const& color, Vec2F const& position) {
   Drawable drawable;
-  drawable.part = LinePart{move(line), lineWidth};
+  drawable.part = LinePart{std::move(line), lineWidth};
   drawable.color = color;
   drawable.position = position;
 
@@ -79,7 +79,7 @@ Drawable Drawable::makeLine(Line2F const& line, float lineWidth, Color const& co
 
 Drawable Drawable::makePoly(PolyF poly, Color const& color, Vec2F const& position) {
   Drawable drawable;
-  drawable.part = PolyPart{move(poly)};
+  drawable.part = PolyPart{std::move(poly)};
   drawable.color = color;
   drawable.position = position;
 
@@ -98,7 +98,7 @@ Drawable Drawable::makeImage(AssetPath image, float pixelSize, bool centered, Ve
   if (pixelSize != 1.0f)
     transformation.scale(pixelSize);
 
-  drawable.part = ImagePart{move(image), move(transformation)};
+  drawable.part = ImagePart{std::move(image), std::move(transformation)};
   drawable.position = position;
   drawable.color = color;
 
@@ -132,7 +132,7 @@ Drawable::Drawable(Json const& json) {
         transformation.scale(*scale);
     }
 
-    part = ImagePart{move(imageString), move(transformation)};
+    part = ImagePart{std::move(imageString), std::move(transformation)};
   }
   position = json.opt("position").apply(jsonToVec2F).value();
   color = json.opt("color").apply(jsonToColor).value(Color::White);
diff --git a/source/game/StarEffectEmitter.cpp b/source/game/StarEffectEmitter.cpp
index 1443172..ddb0355 100644
--- a/source/game/StarEffectEmitter.cpp
+++ b/source/game/StarEffectEmitter.cpp
@@ -15,11 +15,11 @@ EffectEmitter::EffectEmitter() {
 
 void EffectEmitter::addEffectSources(String const& position, StringSet effectSources) {
   for (auto& e : effectSources)
-    m_newSources.add({position, move(e)});
+    m_newSources.add({position, std::move(e)});
 }
 
 void EffectEmitter::setSourcePosition(String name, Vec2F const& position) {
-  m_positions[move(name)] = position;
+  m_positions[std::move(name)] = position;
 }
 
 void EffectEmitter::setDirection(Direction direction) {
@@ -32,7 +32,7 @@ void EffectEmitter::setBaseVelocity(Vec2F const& velocity) {
 
 void EffectEmitter::tick(float dt, EntityMode mode) {
   if (mode == EntityMode::Master) {
-    m_activeSources.set(move(m_newSources));
+    m_activeSources.set(std::move(m_newSources));
     m_newSources.clear();
   } else {
     if (!m_newSources.empty())
diff --git a/source/game/StarEffectSourceDatabase.cpp b/source/game/StarEffectSourceDatabase.cpp
index fe65a2a..ab3c112 100644
--- a/source/game/StarEffectSourceDatabase.cpp
+++ b/source/game/StarEffectSourceDatabase.cpp
@@ -183,7 +183,7 @@ List<AudioInstancePtr> soundsFromDefinition(Json const& config, Vec2F const& pos
       sample->setRangeMultiplier(entry.getFloat("audioRangeMultiplier", 1.0f));
       sample->setPosition(position);
 
-      result.append(move(sample));
+      result.append(std::move(sample));
     }
     return result;
   }
diff --git a/source/game/StarEntityMap.cpp b/source/game/StarEntityMap.cpp
index 6a22a67..c82c7bd 100644
--- a/source/game/StarEntityMap.cpp
+++ b/source/game/StarEntityMap.cpp
@@ -68,7 +68,7 @@ void EntityMap::addEntity(EntityPtr entity) {
   if (uniqueId && m_uniqueMap.hasLeftValue(*uniqueId))
     throw EntityMapException::format("Duplicate entity unique id ({}) on entity id ({}) in EntityMap::addEntity", *uniqueId, entityId);
 
-  m_spatialMap.set(entityId, m_geometry.splitRect(boundBox, position), move(entity));
+  m_spatialMap.set(entityId, m_geometry.splitRect(boundBox, position), std::move(entity));
   if (uniqueId)
     m_uniqueMap.add(*uniqueId, entityId);
 }
diff --git a/source/game/StarEntityMap.hpp b/source/game/StarEntityMap.hpp
index bf8a12a..73883e4 100644
--- a/source/game/StarEntityMap.hpp
+++ b/source/game/StarEntityMap.hpp
@@ -182,7 +182,7 @@ List<shared_ptr<EntityT>> EntityMap::atTile(Vec2I const& pos) const {
   List<shared_ptr<EntityT>> list;
   forEachEntityAtTile(pos, [&](TileEntityPtr const& entity) {
       if (auto e = as<EntityT>(entity))
-        list.append(move(e));
+        list.append(std::move(e));
       return false;
     });
   return list;
diff --git a/source/game/StarEntityRendering.cpp b/source/game/StarEntityRendering.cpp
index a18bf16..1390cd7 100644
--- a/source/game/StarEntityRendering.cpp
+++ b/source/game/StarEntityRendering.cpp
@@ -9,40 +9,40 @@ RenderCallback::~RenderCallback() {}
 void RenderCallback::addDrawables(List<Drawable> drawables, EntityRenderLayer renderLayer, Vec2F translate) {
   for (auto& drawable : drawables) {
     drawable.translate(translate);
-    addDrawable(move(drawable), renderLayer);
+    addDrawable(std::move(drawable), renderLayer);
   }
 }
 
 void RenderCallback::addLightSources(List<LightSource> lightSources, Vec2F translate) {
   for (auto& lightSource : lightSources) {
     lightSource.translate(translate);
-    addLightSource(move(lightSource));
+    addLightSource(std::move(lightSource));
   }
 }
 
 void RenderCallback::addParticles(List<Particle> particles, Vec2F translate) {
   for (auto& particle : particles) {
     particle.translate(translate);
-    addParticle(move(particle));
+    addParticle(std::move(particle));
   }
 }
 
 void RenderCallback::addAudios(List<AudioInstancePtr> audios, Vec2F translate) {
   for (auto& audio : audios) {
     audio->translate(translate);
-    addAudio(move(audio));
+    addAudio(std::move(audio));
   }
 }
 
 void RenderCallback::addTilePreviews(List<PreviewTile> previews) {
   for (auto& preview : previews)
-    addTilePreview(move(preview));
+    addTilePreview(std::move(preview));
 }
 
 void RenderCallback::addOverheadBars(List<OverheadBar> bars, Vec2F translate) {
   for (auto& bar : bars) {
     bar.entityPosition += translate;
-    addOverheadBar(move(bar));
+    addOverheadBar(std::move(bar));
   }
 }
 
diff --git a/source/game/StarEntityRenderingTypes.cpp b/source/game/StarEntityRenderingTypes.cpp
index 12a80fa..bf118c7 100644
--- a/source/game/StarEntityRenderingTypes.cpp
+++ b/source/game/StarEntityRenderingTypes.cpp
@@ -114,7 +114,7 @@ OverheadBar::OverheadBar(Json const& json) {
 }
 
 OverheadBar::OverheadBar(Maybe<String> icon, float percentage, Color color, bool detailOnly)
-  : icon(move(icon)), percentage(percentage), color(move(color)), detailOnly(detailOnly) {}
+  : icon(std::move(icon)), percentage(percentage), color(std::move(color)), detailOnly(detailOnly) {}
 
 EnumMap<EntityHighlightEffectType> const EntityHighlightEffectTypeNames{
   {EntityHighlightEffectType::None, "none"},
diff --git a/source/game/StarFallingBlocksAgent.cpp b/source/game/StarFallingBlocksAgent.cpp
index 945daf5..bb9dd84 100644
--- a/source/game/StarFallingBlocksAgent.cpp
+++ b/source/game/StarFallingBlocksAgent.cpp
@@ -5,7 +5,7 @@
 namespace Star {
 
 FallingBlocksAgent::FallingBlocksAgent(FallingBlocksFacadePtr worldFacade)
-  : m_facade(move(worldFacade)) {
+  : m_facade(std::move(worldFacade)) {
   m_immediateUpwardPropagateProbability = Root::singleton().assets()->json("/worldserver.config:fallingBlocksImmediateUpwardPropogateProbability").toFloat();
 }
 
diff --git a/source/game/StarForceRegions.cpp b/source/game/StarForceRegions.cpp
index ec6bddd..5fae0e2 100644
--- a/source/game/StarForceRegions.cpp
+++ b/source/game/StarForceRegions.cpp
@@ -5,15 +5,15 @@
 namespace Star {
 
 PhysicsCategoryFilter PhysicsCategoryFilter::whitelist(StringSet categories) {
-  return PhysicsCategoryFilter(Whitelist, move(categories));
+  return PhysicsCategoryFilter(Whitelist, std::move(categories));
 }
 
 PhysicsCategoryFilter PhysicsCategoryFilter::blacklist(StringSet categories) {
-  return PhysicsCategoryFilter(Blacklist, move(categories));
+  return PhysicsCategoryFilter(Blacklist, std::move(categories));
 }
 
 PhysicsCategoryFilter::PhysicsCategoryFilter(Type type, StringSet categories)
-  : type(type), categories(move(categories)) {}
+  : type(type), categories(std::move(categories)) {}
 
 bool PhysicsCategoryFilter::check(StringSet const& otherCategories) const {
   bool intersection = categories.hasIntersection(otherCategories);
diff --git a/source/game/StarHumanoid.cpp b/source/game/StarHumanoid.cpp
index 64c5f46..78b615b 100644
--- a/source/game/StarHumanoid.cpp
+++ b/source/game/StarHumanoid.cpp
@@ -332,47 +332,47 @@ HumanoidIdentity const& Humanoid::identity() const {
 }
 
 void Humanoid::setHeadArmorDirectives(Directives directives) {
-  m_headArmorDirectives = move(directives);
+  m_headArmorDirectives = std::move(directives);
 }
 
 void Humanoid::setHeadArmorFrameset(String headFrameset) {
-  m_headArmorFrameset = move(headFrameset);
+  m_headArmorFrameset = std::move(headFrameset);
 }
 
 void Humanoid::setChestArmorDirectives(Directives directives) {
-  m_chestArmorDirectives = move(directives);
+  m_chestArmorDirectives = std::move(directives);
 }
 
 void Humanoid::setChestArmorFrameset(String chest) {
-  m_chestArmorFrameset = move(chest);
+  m_chestArmorFrameset = std::move(chest);
 }
 
 void Humanoid::setBackSleeveFrameset(String backSleeveFrameset) {
-  m_backSleeveFrameset = move(backSleeveFrameset);
+  m_backSleeveFrameset = std::move(backSleeveFrameset);
 }
 
 void Humanoid::setFrontSleeveFrameset(String frontSleeveFrameset) {
-  m_frontSleeveFrameset = move(frontSleeveFrameset);
+  m_frontSleeveFrameset = std::move(frontSleeveFrameset);
 }
 
 void Humanoid::setLegsArmorDirectives(Directives directives) {
-  m_legsArmorDirectives = move(directives);
+  m_legsArmorDirectives = std::move(directives);
 }
 
 void Humanoid::setLegsArmorFrameset(String legsFrameset) {
-  m_legsArmorFrameset = move(legsFrameset);
+  m_legsArmorFrameset = std::move(legsFrameset);
 }
 
 void Humanoid::setBackArmorDirectives(Directives directives) {
-  m_backArmorDirectives = move(directives);
+  m_backArmorDirectives = std::move(directives);
 }
 
 void Humanoid::setBackArmorFrameset(String backFrameset) {
-  m_backArmorFrameset = move(backFrameset);
+  m_backArmorFrameset = std::move(backFrameset);
 }
 
 void Humanoid::setHelmetMaskDirectives(Directives helmetMaskDirectives) {
-  m_helmetMaskDirectives = move(helmetMaskDirectives);
+  m_helmetMaskDirectives = std::move(helmetMaskDirectives);
 }
 
 void Humanoid::setBodyHidden(bool hidden) {
@@ -453,16 +453,16 @@ void Humanoid::setPrimaryHandParameters(bool holdingItem, float angle, float ite
 }
 
 void Humanoid::setPrimaryHandFrameOverrides(String backFrameOverride, String frontFrameOverride) {
-  m_primaryHand.backFrame = !backFrameOverride.empty() ? move(backFrameOverride) : "rotation";
-  m_primaryHand.frontFrame = !frontFrameOverride.empty() ? move(frontFrameOverride) : "rotation";
+  m_primaryHand.backFrame = !backFrameOverride.empty() ? std::move(backFrameOverride) : "rotation";
+  m_primaryHand.frontFrame = !frontFrameOverride.empty() ? std::move(frontFrameOverride) : "rotation";
 }
 
 void Humanoid::setPrimaryHandDrawables(List<Drawable> drawables) {
-  m_primaryHand.itemDrawables = move(drawables);
+  m_primaryHand.itemDrawables = std::move(drawables);
 }
 
 void Humanoid::setPrimaryHandNonRotatedDrawables(List<Drawable> drawables) {
-  m_primaryHand.nonRotatedDrawables = move(drawables);
+  m_primaryHand.nonRotatedDrawables = std::move(drawables);
 }
 
 void Humanoid::setAltHandParameters(bool holdingItem, float angle, float itemAngle, bool recoil,
@@ -475,16 +475,16 @@ void Humanoid::setAltHandParameters(bool holdingItem, float angle, float itemAng
 }
 
 void Humanoid::setAltHandFrameOverrides(String backFrameOverride, String frontFrameOverride) {
-  m_altHand.backFrame = !backFrameOverride.empty() ? move(backFrameOverride) : "rotation";
-  m_altHand.frontFrame = !frontFrameOverride.empty() ? move(frontFrameOverride) : "rotation";
+  m_altHand.backFrame = !backFrameOverride.empty() ? std::move(backFrameOverride) : "rotation";
+  m_altHand.frontFrame = !frontFrameOverride.empty() ? std::move(frontFrameOverride) : "rotation";
 }
 
 void Humanoid::setAltHandDrawables(List<Drawable> drawables) {
-  m_altHand.itemDrawables = move(drawables);
+  m_altHand.itemDrawables = std::move(drawables);
 }
 
 void Humanoid::setAltHandNonRotatedDrawables(List<Drawable> drawables) {
-  m_altHand.nonRotatedDrawables = move(drawables);
+  m_altHand.nonRotatedDrawables = std::move(drawables);
 }
 
 void Humanoid::animate(float dt) {
@@ -529,12 +529,12 @@ List<Drawable> Humanoid::render(bool withItems, bool withRotation) {
     if (m_facingDirection == Direction::Left)
       drawable.scale(Vec2F(-1, 1));
     drawable.fullbright = drawable.fullbright || forceFullbright;
-    drawables.append(move(drawable));
+    drawables.append(std::move(drawable));
   };
 
   auto backArmDrawable = [&](String const& frameSet, Directives const& directives) -> Drawable {
     String image = strf("{}:{}", frameSet, backHand.backFrame);
-    Drawable backArm = Drawable::makeImage(move(image), 1.0f / TilePixels, true, backArmFrameOffset);
+    Drawable backArm = Drawable::makeImage(std::move(image), 1.0f / TilePixels, true, backArmFrameOffset);
     backArm.imagePart().addDirectives(directives, true);
     backArm.rotate(backHand.angle, backArmFrameOffset + m_backArmRotationCenter + m_backArmOffset);
     return backArm;
@@ -552,9 +552,9 @@ List<Drawable> Humanoid::render(bool withItems, bool withRotation) {
     else
       image = strf("{}:{}.{}", m_backArmorFrameset, frameGroup, bodyStateSeq);
 
-    auto drawable = Drawable::makeImage(move(image), 1.0f / TilePixels, true, Vec2F());
+    auto drawable = Drawable::makeImage(std::move(image), 1.0f / TilePixels, true, Vec2F());
     drawable.imagePart().addDirectives(getBackDirectives(), true);
-    addDrawable(move(drawable));
+    addDrawable(std::move(drawable));
   }
 
   if (backHand.holdingItem && !dance.isValid() && withItems) {
@@ -562,7 +562,7 @@ List<Drawable> Humanoid::render(bool withItems, bool withRotation) {
       for (auto& backHandItem : backHand.itemDrawables) {
         backHandItem.translate(m_frontHandPosition + backArmFrameOffset + m_backArmOffset);
         backHandItem.rotate(backHand.itemAngle, backArmFrameOffset + m_backArmRotationCenter + m_backArmOffset);
-        addDrawable(move(backHandItem));
+        addDrawable(std::move(backHandItem));
       }
     };
     if (!m_twoHanded && backHand.outsideOfHand)
@@ -585,11 +585,11 @@ List<Drawable> Humanoid::render(bool withItems, bool withRotation) {
         position = m_identity.personality.armOffset / TilePixels;
       } else
         image = strf("{}:{}.{}", m_backArmFrameset, frameBase(m_state), armStateSeq);
-      auto drawable = Drawable::makeImage(move(image), 1.0f / TilePixels, true, position);
+      auto drawable = Drawable::makeImage(std::move(image), 1.0f / TilePixels, true, position);
       drawable.imagePart().addDirectives(getBodyDirectives(), true);
       if (dance.isValid())
         drawable.rotate(danceStep->backArmRotation);
-      addDrawable(move(drawable), m_bodyFullbright);
+      addDrawable(std::move(drawable), m_bodyFullbright);
     }
     if (!m_backSleeveFrameset.empty()) {
       String image;
@@ -602,11 +602,11 @@ List<Drawable> Humanoid::render(bool withItems, bool withRotation) {
         position = m_identity.personality.armOffset / TilePixels;
       } else
         image = strf("{}:{}.{}", m_backSleeveFrameset, frameBase(m_state), armStateSeq);
-      auto drawable = Drawable::makeImage(move(image), 1.0f / TilePixels, true, position);
+      auto drawable = Drawable::makeImage(std::move(image), 1.0f / TilePixels, true, position);
       drawable.imagePart().addDirectives(getChestDirectives(), true);
       if (dance.isValid())
         drawable.rotate(danceStep->backArmRotation);
-      addDrawable(move(drawable));
+      addDrawable(std::move(drawable));
     }
   }
 
@@ -628,23 +628,23 @@ List<Drawable> Humanoid::render(bool withItems, bool withRotation) {
 
   if (!m_headFrameset.empty() && !m_bodyHidden) {
     String image = strf("{}:normal", m_headFrameset);
-    auto drawable = Drawable::makeImage(move(image), 1.0f / TilePixels, true, headPosition);
+    auto drawable = Drawable::makeImage(std::move(image), 1.0f / TilePixels, true, headPosition);
     drawable.imagePart().addDirectives(getBodyDirectives(), true);
-    addDrawable(move(drawable), m_bodyFullbright);
+    addDrawable(std::move(drawable), m_bodyFullbright);
   }
 
   if (!m_emoteFrameset.empty() && !m_bodyHidden) {
     String image = strf("{}:{}.{}", m_emoteFrameset, emoteFrameBase(m_emoteState), emoteStateSeq);
-    auto drawable = Drawable::makeImage(move(image), 1.0f / TilePixels, true, headPosition);
+    auto drawable = Drawable::makeImage(std::move(image), 1.0f / TilePixels, true, headPosition);
     drawable.imagePart().addDirectives(getEmoteDirectives(), true);
-    addDrawable(move(drawable), m_bodyFullbright);
+    addDrawable(std::move(drawable), m_bodyFullbright);
   }
 
   if (!m_hairFrameset.empty() && !m_bodyHidden) {
     String image = strf("{}:normal", m_hairFrameset);
-    auto drawable = Drawable::makeImage(move(image), 1.0f / TilePixels, true, headPosition);
+    auto drawable = Drawable::makeImage(std::move(image), 1.0f / TilePixels, true, headPosition);
     drawable.imagePart().addDirectives(getHairDirectives(), true).addDirectives(getHelmetMaskDirectives(), true);
-    addDrawable(move(drawable), m_bodyFullbright);
+    addDrawable(std::move(drawable), m_bodyFullbright);
   }
 
   if (!m_bodyFrameset.empty() && !m_bodyHidden) {
@@ -655,9 +655,9 @@ List<Drawable> Humanoid::render(bool withItems, bool withRotation) {
       image = strf("{}:{}", m_bodyFrameset, m_identity.personality.idle);
     else
       image = strf("{}:{}.{}", m_bodyFrameset, frameBase(m_state), bodyStateSeq);
-    auto drawable = Drawable::makeImage(move(image), 1.0f / TilePixels, true, {});
+    auto drawable = Drawable::makeImage(std::move(image), 1.0f / TilePixels, true, {});
     drawable.imagePart().addDirectives(getBodyDirectives(), true);
-    addDrawable(move(drawable), m_bodyFullbright);
+    addDrawable(std::move(drawable), m_bodyFullbright);
   }
 
   if (!m_legsArmorFrameset.empty()) {
@@ -668,9 +668,9 @@ List<Drawable> Humanoid::render(bool withItems, bool withRotation) {
       image = strf("{}:{}", m_legsArmorFrameset, m_identity.personality.idle);
     else
       image = strf("{}:{}.{}", m_legsArmorFrameset, frameBase(m_state), bodyStateSeq);
-    auto drawable = Drawable::makeImage(move(image), 1.0f / TilePixels, true, {});
+    auto drawable = Drawable::makeImage(std::move(image), 1.0f / TilePixels, true, {});
     drawable.imagePart().addDirectives(getLegsDirectives(), true);
-    addDrawable(move(drawable));
+    addDrawable(std::move(drawable));
   }
 
   if (!m_chestArmorFrameset.empty()) {
@@ -690,30 +690,30 @@ List<Drawable> Humanoid::render(bool withItems, bool withRotation) {
       image = strf("{}:chest.1", m_chestArmorFrameset);
     if (m_state != Duck)
       position[1] += bobYOffset;
-    auto drawable = Drawable::makeImage(move(image), 1.0f / TilePixels, true, position);
+    auto drawable = Drawable::makeImage(std::move(image), 1.0f / TilePixels, true, position);
     drawable.imagePart().addDirectives(getChestDirectives(), true);
-    addDrawable(move(drawable));
+    addDrawable(std::move(drawable));
   }
 
   if (!m_facialHairFrameset.empty() && !m_bodyHidden) {
     String image = strf("{}:normal", m_facialHairFrameset);
-    auto drawable = Drawable::makeImage(move(image), 1.0f / TilePixels, true, headPosition);
+    auto drawable = Drawable::makeImage(std::move(image), 1.0f / TilePixels, true, headPosition);
     drawable.imagePart().addDirectives(getFacialHairDirectives(), true).addDirectives(getHelmetMaskDirectives(), true);
-    addDrawable(move(drawable), m_bodyFullbright);
+    addDrawable(std::move(drawable), m_bodyFullbright);
   }
 
   if (!m_facialMaskFrameset.empty() && !m_bodyHidden) {
     String image = strf("{}:normal", m_facialMaskFrameset);
-    auto drawable = Drawable::makeImage(move(image), 1.0f / TilePixels, true, headPosition);
+    auto drawable = Drawable::makeImage(std::move(image), 1.0f / TilePixels, true, headPosition);
     drawable.imagePart().addDirectives(getFacialMaskDirectives(), true).addDirectives(getHelmetMaskDirectives(), true);
-    addDrawable(move(drawable));
+    addDrawable(std::move(drawable));
   }
 
   if (!m_headArmorFrameset.empty()) {
     String image = strf("{}:normal", m_headArmorFrameset);
-    auto drawable = Drawable::makeImage(move(image), 1.0f / TilePixels, true, headPosition);
+    auto drawable = Drawable::makeImage(std::move(image), 1.0f / TilePixels, true, headPosition);
     drawable.imagePart().addDirectives(getHeadDirectives(), true);
-    addDrawable(move(drawable));
+    addDrawable(std::move(drawable));
   }
 
   auto frontArmDrawable = [&](String const& frameSet, Directives const& directives) -> Drawable {
@@ -752,7 +752,7 @@ List<Drawable> Humanoid::render(bool withItems, bool withRotation) {
         position = m_identity.personality.armOffset / TilePixels;
       } else
         image = strf("{}:{}.{}", m_frontArmFrameset, frameBase(m_state), armStateSeq);
-      auto drawable = Drawable::makeImage(move(image), 1.0f / TilePixels, true, position);
+      auto drawable = Drawable::makeImage(std::move(image), 1.0f / TilePixels, true, position);
       drawable.imagePart().addDirectives(getBodyDirectives(), true);
       if (dance.isValid())
         drawable.rotate(danceStep->frontArmRotation);
@@ -826,104 +826,104 @@ List<Drawable> Humanoid::renderPortrait(PortraitMode mode) const {
   if (mode != PortraitMode::Head) {
     if (!m_backArmFrameset.empty()) {
       String image = strf("{}:{}", m_backArmFrameset, personality.armIdle);
-      Drawable drawable = Drawable::makeImage(move(image), 1.0f, true, personality.armOffset);
+      Drawable drawable = Drawable::makeImage(std::move(image), 1.0f, true, personality.armOffset);
       drawable.imagePart().addDirectives(getBodyDirectives(), true);
-      addDrawable(move(drawable));
+      addDrawable(std::move(drawable));
     }
     if (dressed && !m_backSleeveFrameset.empty()) {
       String image = strf("{}:{}", m_backSleeveFrameset, personality.armIdle);
-      Drawable drawable = Drawable::makeImage(move(image), 1.0f, true, personality.armOffset);
+      Drawable drawable = Drawable::makeImage(std::move(image), 1.0f, true, personality.armOffset);
       drawable.imagePart().addDirectives(getChestDirectives(), true);
-      addDrawable(move(drawable));
+      addDrawable(std::move(drawable));
     }
     if (mode != PortraitMode::Bust) {
       if (dressed && !m_backArmorFrameset.empty()) {
         String image = strf("{}:{}", m_backArmorFrameset, personality.idle);
-        Drawable drawable = Drawable::makeImage(move(image), 1.0f, true, {});
+        Drawable drawable = Drawable::makeImage(std::move(image), 1.0f, true, {});
         drawable.imagePart().addDirectives(getBackDirectives(), true);
-        addDrawable(move(drawable));
+        addDrawable(std::move(drawable));
       }
     }
   }
 
   if (!m_headFrameset.empty()) {
     String image = strf("{}:normal", m_headFrameset);
-    Drawable drawable = Drawable::makeImage(move(image), 1.0f, true, personality.headOffset);
+    Drawable drawable = Drawable::makeImage(std::move(image), 1.0f, true, personality.headOffset);
     drawable.imagePart().addDirectives(getBodyDirectives(), true);
-    addDrawable(move(drawable));
+    addDrawable(std::move(drawable));
   }
 
   if (!m_emoteFrameset.empty()) {
     String image = strf("{}:{}.{}", m_emoteFrameset, emoteFrameBase(m_emoteState), emoteStateSeq);
-    Drawable drawable = Drawable::makeImage(move(image), 1.0f, true, personality.headOffset);
+    Drawable drawable = Drawable::makeImage(std::move(image), 1.0f, true, personality.headOffset);
     drawable.imagePart().addDirectives(getEmoteDirectives(), true);
-    addDrawable(move(drawable));
+    addDrawable(std::move(drawable));
   }
 
   if (!m_hairFrameset.empty()) {
     String image = strf("{}:normal", m_hairFrameset);
-    Drawable drawable = Drawable::makeImage(move(image), 1.0f, true, personality.headOffset);
+    Drawable drawable = Drawable::makeImage(std::move(image), 1.0f, true, personality.headOffset);
     drawable.imagePart().addDirectives(getHairDirectives(), true).addDirectives(helmetMaskDirective, true);
-    addDrawable(move(drawable));
+    addDrawable(std::move(drawable));
   }
 
   if (!m_bodyFrameset.empty()) {
     String image = strf("{}:{}", m_bodyFrameset, personality.idle);
-    Drawable drawable = Drawable::makeImage(move(image), 1.0f, true, {});
+    Drawable drawable = Drawable::makeImage(std::move(image), 1.0f, true, {});
     drawable.imagePart().addDirectives(getBodyDirectives(), true);
-    addDrawable(move(drawable));
+    addDrawable(std::move(drawable));
   }
 
   if (mode != PortraitMode::Head) {
     if (dressed && !m_legsArmorFrameset.empty()) {
       String image = strf("{}:{}", m_legsArmorFrameset, personality.idle);
-      Drawable drawable = Drawable::makeImage(move(image), 1.0f, true, {});
+      Drawable drawable = Drawable::makeImage(std::move(image), 1.0f, true, {});
       drawable.imagePart().addDirectives(getLegsDirectives(), true);
-      addDrawable(move(drawable));
+      addDrawable(std::move(drawable));
     }
 
     if (dressed && !m_chestArmorFrameset.empty()) {
       String image = strf("{}:{}", m_chestArmorFrameset, personality.idle);
-      Drawable drawable = Drawable::makeImage(move(image), 1.0f, true, {});
+      Drawable drawable = Drawable::makeImage(std::move(image), 1.0f, true, {});
       drawable.imagePart().addDirectives(getChestDirectives(), true);
-      addDrawable(move(drawable));
+      addDrawable(std::move(drawable));
     }
   }
 
   if (!m_facialHairFrameset.empty()) {
     String image = strf("{}:normal", m_facialHairFrameset);
-    Drawable drawable = Drawable::makeImage(move(image), 1.0f, true, personality.headOffset);
+    Drawable drawable = Drawable::makeImage(std::move(image), 1.0f, true, personality.headOffset);
     drawable.imagePart().addDirectives(getFacialHairDirectives(), true).addDirectives(helmetMaskDirective, true);
-    addDrawable(move(drawable));
+    addDrawable(std::move(drawable));
   }
 
   if (!m_facialMaskFrameset.empty()) {
     String image = strf("{}:normal", m_facialMaskFrameset);
-    Drawable drawable = Drawable::makeImage(move(image), 1.0f, true, personality.headOffset);
+    Drawable drawable = Drawable::makeImage(std::move(image), 1.0f, true, personality.headOffset);
     drawable.imagePart().addDirectives(getFacialMaskDirectives(), true).addDirectives(helmetMaskDirective, true);
-    addDrawable(move(drawable));
+    addDrawable(std::move(drawable));
   }
 
   if (dressed && !m_headArmorFrameset.empty()) {
     String image = strf("{}:normal", m_headArmorFrameset);
-    Drawable drawable = Drawable::makeImage(move(image), 1.0f, true, personality.headOffset);
+    Drawable drawable = Drawable::makeImage(std::move(image), 1.0f, true, personality.headOffset);
     drawable.imagePart().addDirectives(getHeadDirectives(), true);
-    addDrawable(move(drawable));
+    addDrawable(std::move(drawable));
   }
 
   if (mode != PortraitMode::Head) {
     if (!m_frontArmFrameset.empty()) {
       String image = strf("{}:{}", m_frontArmFrameset, personality.armIdle);
-      Drawable drawable = Drawable::makeImage(move(image), 1.0f, true, personality.armOffset);
+      Drawable drawable = Drawable::makeImage(std::move(image), 1.0f, true, personality.armOffset);
       drawable.imagePart().addDirectives(getBodyDirectives(), true);
-      addDrawable(move(drawable));
+      addDrawable(std::move(drawable));
     }
 
     if (dressed && !m_frontSleeveFrameset.empty()) {
       String image = strf("{}:{}", m_frontSleeveFrameset, personality.armIdle);
-      Drawable drawable = Drawable::makeImage(move(image), 1.0f, true, personality.armOffset);
+      Drawable drawable = Drawable::makeImage(std::move(image), 1.0f, true, personality.armOffset);
       drawable.imagePart().addDirectives(getChestDirectives(), true);
-      addDrawable(move(drawable));
+      addDrawable(std::move(drawable));
     }
   }
 
diff --git a/source/game/StarImageMetadataDatabase.cpp b/source/game/StarImageMetadataDatabase.cpp
index c5ebd84..47ff97f 100644
--- a/source/game/StarImageMetadataDatabase.cpp
+++ b/source/game/StarImageMetadataDatabase.cpp
@@ -136,7 +136,7 @@ AssetPath ImageMetadataDatabase::filterProcessing(AssetPath const& path) {
     }
     });
 
-  newPath.directives = move(filtered);
+  newPath.directives = std::move(filtered);
   return newPath;
 }
 
diff --git a/source/game/StarInput.cpp b/source/game/StarInput.cpp
index 57899bf..3a2fa9f 100644
--- a/source/game/StarInput.cpp
+++ b/source/game/StarInput.cpp
@@ -48,7 +48,7 @@ Json keyModsToJson(KeyMod mod) {
   if (bool(mod & KeyMod::AltGr )) array.emplace_back("AltGr" );
   if (bool(mod & KeyMod::Scroll)) array.emplace_back("Scroll");
 
-  return array.empty() ? Json() : move(array);
+  return array.empty() ? Json() : std::move(array);
 }
 
 // Optional pointer argument to output calculated priority
@@ -146,19 +146,19 @@ Input::Bind Input::bindFromJson(Json const& json) {
     KeyBind keyBind;
     keyBind.key = KeyNames.getLeft(value.toString());
     keyBind.mods = keyModsFromJson(json.getArray("mods", {}), &keyBind.priority);
-    bind = move(keyBind);
+    bind = std::move(keyBind);
   }
   else if (type == "mouse") {
     MouseBind mouseBind;
     mouseBind.button = MouseButtonNames.getLeft(value.toString());
     mouseBind.mods = keyModsFromJson(json.getArray("mods", {}), &mouseBind.priority);
-    bind = move(mouseBind);
+    bind = std::move(mouseBind);
   }
   else if (type == "controller") {
     ControllerBind controllerBind;
     controllerBind.button = ControllerButtonNames.getLeft(value.toString());
     controllerBind.controller = json.getUInt("controller", 0);
-    bind = move(controllerBind);
+    bind = std::move(controllerBind);
   }
 
   return bind;
@@ -171,8 +171,8 @@ Json Input::bindToJson(Bind const& bind) {
       {"value", KeyNames.getRight(keyBind->key)}
     }; // don't want empty mods to exist as null entry
     if (auto mods = keyModsToJson(keyBind->mods))
-      obj.emplace("mods", move(mods));
-    return move(obj);
+      obj.emplace("mods", std::move(mods));
+    return obj;
   }
   else if (auto mouseBind = bind.ptr<MouseBind>()) {
     auto obj = JsonObject{
@@ -180,8 +180,8 @@ Json Input::bindToJson(Bind const& bind) {
       {"value", MouseButtonNames.getRight(mouseBind->button)}
     };
     if (auto mods = keyModsToJson(mouseBind->mods))
-      obj.emplace("mods", move(mods));
-    return move(obj);
+      obj.emplace("mods", std::move(mods));
+    return obj;
   }
   else if (auto controllerBind = bind.ptr<ControllerBind>()) {
     return JsonObject{
@@ -219,7 +219,7 @@ void Input::BindEntry::updated() {
   String path = strf("{}.{}", InputBindingConfigRoot, category->id);
   if (!config->getPath(path).isType(Json::Type::Object)) {
     config->setPath(path, JsonObject{
-      { id, move(array) }
+      { id, std::move(array) }
     });
   }
   else {
@@ -577,7 +577,7 @@ Json Input::getDefaultBinds(String const& categoryId, String const& bindId) {
   for (Bind const& bind : bindEntry(categoryId, bindId).defaultBinds)
     array.emplace_back(bindToJson(bind));
 
-  return move(array);
+  return array;
 }
 
 Json Input::getBinds(String const& categoryId, String const& bindId) {
@@ -585,7 +585,7 @@ Json Input::getBinds(String const& categoryId, String const& bindId) {
   for (Bind const& bind : bindEntry(categoryId, bindId).customBinds)
     array.emplace_back(bindToJson(bind));
 
-  return move(array);
+  return array;
 }
 
 void Input::setBinds(String const& categoryId, String const& bindId, Json const& jBinds) {
@@ -595,7 +595,7 @@ void Input::setBinds(String const& categoryId, String const& bindId, Json const&
   for (Json const& jBind : jBinds.toArray())
     binds.emplace_back(bindFromJson(jBind));
 
-  entry.customBinds = move(binds);
+  entry.customBinds = std::move(binds);
   entry.updated();
 }
 
diff --git a/source/game/StarItem.cpp b/source/game/StarItem.cpp
index f920a64..bac5f0b 100644
--- a/source/game/StarItem.cpp
+++ b/source/game/StarItem.cpp
@@ -9,9 +9,9 @@
 namespace Star {
 
 Item::Item(Json config, String directory, Json parameters) {
-  m_config = move(config);
-  m_directory = move(directory);
-  m_parameters = move(parameters);
+  m_config = std::move(config);
+  m_directory = std::move(directory);
+  m_parameters = std::move(parameters);
   m_name = m_config.getString("itemName");
   m_count = 1;
 
@@ -33,7 +33,7 @@ Item::Item(Json config, String directory, Json parameters) {
         iconDrawables.emplaceAppend(drawable);
       }
     }
-    setIconDrawables(move(iconDrawables));
+    setIconDrawables(std::move(iconDrawables));
   } else {
     auto image = AssetPath::relativeTo(m_directory, inventoryIcon.toString());
     setIconDrawables({Drawable::makeImage(image, 1.0f, true, Vec2F())});
@@ -214,7 +214,7 @@ void Item::setPrice(uint64_t price) {
 }
 
 void Item::setIconDrawables(List<Drawable> drawables) {
-  m_iconDrawables = move(drawables);
+  m_iconDrawables = std::move(drawables);
   auto boundBox = Drawable::boundBoxAll(m_iconDrawables, true);
   if (!boundBox.isEmpty()) {
     for (auto& drawable : m_iconDrawables)
diff --git a/source/game/StarItemBag.cpp b/source/game/StarItemBag.cpp
index 0314f16..8abdd6f 100644
--- a/source/game/StarItemBag.cpp
+++ b/source/game/StarItemBag.cpp
@@ -100,7 +100,7 @@ List<ItemPtr> ItemBag::takeAll() {
   List<ItemPtr> taken;
   for (size_t i = 0; i < size(); ++i) {
     if (auto& item = at(i))
-      taken.append(move(item));
+      taken.append(std::move(item));
   }
   return taken;
 }
@@ -271,7 +271,7 @@ ItemPtr ItemBag::addItems(ItemPtr items) {
       if (items->empty())
         return {};
     } else {
-      storedItem = move(items);
+      storedItem = std::move(items);
       return {};
     }
   }
@@ -292,7 +292,7 @@ ItemPtr ItemBag::stackItems(ItemPtr items) {
       if (items->empty())
         return {};
     } else {
-      storedItem = move(items);
+      storedItem = std::move(items);
       return {};
     }
   }
diff --git a/source/game/StarItemDatabase.cpp b/source/game/StarItemDatabase.cpp
index 4a72ab5..0eccb2e 100644
--- a/source/game/StarItemDatabase.cpp
+++ b/source/game/StarItemDatabase.cpp
@@ -228,7 +228,7 @@ ItemPtr ItemDatabase::itemShared(ItemDescriptor descriptor, Maybe<float> level,
     get<2>(entry) = item->parameters().optUInt("seed"); // Seed could've been changed by the buildscript
 
     locker.lock();
-    return m_itemCache.get(entry, [&](ItemCacheEntry const&) -> ItemPtr { return move(item); });
+    return m_itemCache.get(entry, [&](ItemCacheEntry const&) -> ItemPtr { return std::move(item); });
   }
 }
 
@@ -521,10 +521,10 @@ ItemDatabase::ItemData const& ItemDatabase::itemData(String const& name) const {
 
 ItemRecipe ItemDatabase::makeRecipe(List<ItemDescriptor> inputs, ItemDescriptor output, float duration, StringSet groups) const {
   ItemRecipe res;
-  res.inputs = move(inputs);
-  res.output = move(output);
+  res.inputs = std::move(inputs);
+  res.output = std::move(output);
   res.duration = duration;
-  res.groups = move(groups);
+  res.groups = std::move(groups);
   if (auto item = ItemDatabase::itemShared(res.output)) {
     res.outputRarity = item->rarity();
     res.guiFilterString = guiFilterString(item);
@@ -585,12 +585,12 @@ void ItemDatabase::addObjectDropItem(String const& objectPath, Json const& objec
   // execute scripts intended for objects
   customConfig.remove("scripts");
 
-  data.customConfig = move(customConfig);
+  data.customConfig = std::move(customConfig);
 
   if (m_items.contains(data.name))
     throw ItemException(strf("Object drop '{}' shares name with existing item", data.name));
 
-  m_items[data.name] = move(data);
+  m_items[data.name] = std::move(data);
 }
 
 void ItemDatabase::scanItems() {
@@ -694,7 +694,7 @@ void ItemDatabase::addBlueprints() {
 
       configInfo["price"] = baseItem->price();
 
-      blueprintData.customConfig = move(configInfo);
+      blueprintData.customConfig = std::move(configInfo);
       blueprintData.directory = itemData(baseDesc.name()).directory;
 
       m_items[blueprintData.name] = blueprintData;
diff --git a/source/game/StarItemDescriptor.cpp b/source/game/StarItemDescriptor.cpp
index 81f1464..ecc7a59 100644
--- a/source/game/StarItemDescriptor.cpp
+++ b/source/game/StarItemDescriptor.cpp
@@ -8,7 +8,7 @@ namespace Star {
 ItemDescriptor::ItemDescriptor() : m_count(0), m_parameters(JsonObject()) {}
 
 ItemDescriptor::ItemDescriptor(String name, uint64_t count, Json parameters)
-  : m_name(move(name)), m_count(count), m_parameters(move(parameters)) {
+  : m_name(std::move(name)), m_count(count), m_parameters(std::move(parameters)) {
   if (m_parameters.isNull())
     m_parameters = JsonObject();
   if (!m_parameters.isType(Json::Type::Object))
@@ -122,7 +122,7 @@ Json ItemDescriptor::toJson() const {
 }
 
 ItemDescriptor::ItemDescriptor(String name, uint64_t count, Json parameters, Maybe<size_t> parametersHash)
-  : m_name(move(name)), m_count(count), m_parameters(move(parameters)), m_parametersHash(parametersHash) {}
+  : m_name(std::move(name)), m_count(count), m_parameters(std::move(parameters)), m_parametersHash(parametersHash) {}
 
 size_t ItemDescriptor::parametersHash() const {
   if (!m_parametersHash)
diff --git a/source/game/StarItemDrop.cpp b/source/game/StarItemDrop.cpp
index fa3c984..e7eec81 100644
--- a/source/game/StarItemDrop.cpp
+++ b/source/game/StarItemDrop.cpp
@@ -69,7 +69,7 @@ ItemDropPtr ItemDrop::throwDrop(ItemDescriptor const& itemDescriptor, Vec2F cons
 
 ItemDrop::ItemDrop(ItemPtr item)
   : ItemDrop() {
-  m_item = move(item);
+  m_item = std::move(item);
 
   updateCollisionPoly();
 
@@ -94,7 +94,7 @@ ItemDrop::ItemDrop(Json const& diskStore)
 
 ItemDrop::ItemDrop(ByteArray store)
   : ItemDrop() {
-  DataStreamBuffer ds(move(store));
+  DataStreamBuffer ds(std::move(store));
 
   Root::singleton().itemDatabase()->loadItem(ds.read<ItemDescriptor>(), m_item);
   ds.read(m_eternal);
@@ -151,7 +151,7 @@ pair<ByteArray, uint64_t> ItemDrop::writeNetState(uint64_t fromVersion) {
 }
 
 void ItemDrop::readNetState(ByteArray data, float interpolationTime) {
-  m_netGroup.readNetState(move(data), interpolationTime);
+  m_netGroup.readNetState(std::move(data), interpolationTime);
 }
 
 void ItemDrop::enableInterpolation(float extrapolationHint) {
@@ -292,7 +292,7 @@ void ItemDrop::render(RenderCallback* renderCallback) {
     auto drawable = Drawable::makeLine(line, width, beamColor, position());
     (drawable.linePart().endColor = beamColor)->setAlphaF(0.0f);
     drawable.fullbright = true;
-    renderCallback->addDrawable(move(drawable), RenderLayerItemDrop);
+    renderCallback->addDrawable(std::move(drawable), RenderLayerItemDrop);
   }
 
   if (!m_drawables) {
@@ -314,7 +314,7 @@ void ItemDrop::render(RenderCallback* renderCallback) {
   Vec2F dropPosition = position();
   for (Drawable drawable : *m_drawables) {
     drawable.position += dropPosition;
-    renderCallback->addDrawable(move(drawable), renderLayer);
+    renderCallback->addDrawable(std::move(drawable), renderLayer);
   }
 }
 
@@ -323,7 +323,7 @@ void ItemDrop::renderLightSources(RenderCallback* renderCallback) {
   light.pointLight = false;
   light.color = Vec3B::filled(20);
   light.position = position();
-  renderCallback->addLightSource(move(light));
+  renderCallback->addLightSource(std::move(light));
 }
 
 
diff --git a/source/game/StarMaterialRenderProfile.cpp b/source/game/StarMaterialRenderProfile.cpp
index a763f61..975e7fa 100644
--- a/source/game/StarMaterialRenderProfile.cpp
+++ b/source/game/StarMaterialRenderProfile.cpp
@@ -33,7 +33,7 @@ MaterialRenderMatchList parseMaterialRenderMatchList(Json const& matchSpec, Rule
         throw MaterialRenderProfileException(strf("Match position {} outside of maximum rule distance {}",
             matchPoint.position, MaterialRenderProfileMaxNeighborDistance));
       matchPoint.rule = ruleMap.get(matchPointConfig.getString(1));
-      match->matchPoints.append(move(matchPoint));
+      match->matchPoints.append(std::move(matchPoint));
     }
 
     for (auto const& piece : matchConfig.getArray("pieces", {}))
@@ -105,7 +105,7 @@ MaterialRenderProfile parseMaterialRenderProfile(Json const& spec, String const&
         rule->entries.append({MaterialRule::RulePropertyEquals{ruleEntry.getString("propertyName"), ruleEntry.get("propertyValue")}, inverse});
       }
     }
-    profile.rules[pair.first] = move(rule);
+    profile.rules[pair.first] = std::move(rule);
   }
 
   for (auto const& pair : spec.get("pieces").iterateObject()) {
@@ -137,7 +137,7 @@ MaterialRenderProfile parseMaterialRenderProfile(Json const& spec, String const&
       }
     }
 
-    profile.pieces[pair.first] = move(renderPiece);
+    profile.pieces[pair.first] = std::move(renderPiece);
   }
 
   for (auto const& pair : spec.get("matches").iterateArray())
diff --git a/source/game/StarMonster.cpp b/source/game/StarMonster.cpp
index 7e4e399..075235f 100644
--- a/source/game/StarMonster.cpp
+++ b/source/game/StarMonster.cpp
@@ -215,7 +215,7 @@ pair<ByteArray, uint64_t> Monster::writeNetState(uint64_t fromVersion) {
 }
 
 void Monster::readNetState(ByteArray data, float interpolationTime) {
-  m_netGroup.readNetState(move(data), interpolationTime);
+  m_netGroup.readNetState(std::move(data), interpolationTime);
 }
 
 void Monster::enableInterpolation(float extrapolationHint) {
@@ -490,7 +490,7 @@ void Monster::render(RenderCallback* renderCallback) {
   for (auto& drawable : m_networkedAnimator.drawables(position())) {
     if (drawable.isImage())
       drawable.imagePart().addDirectivesGroup(m_statusController->parentDirectives(), true);
-    renderCallback->addDrawable(move(drawable), m_monsterVariant.renderLayer);
+    renderCallback->addDrawable(std::move(drawable), m_monsterVariant.renderLayer);
   }
 
   renderCallback->addAudios(m_networkedAnimatorDynamicTarget.pullNewAudios());
@@ -593,7 +593,7 @@ LuaCallbacks Monster::makeMonsterCallbacks() {
     });
 
   callbacks.registerCallback("setDropPool", [this](Json dropPool) {
-      m_dropPool = move(dropPool);
+      m_dropPool = std::move(dropPool);
     });
 
   callbacks.registerCallback("toAbsolutePosition", [this](Vec2F const& p) {
@@ -671,7 +671,7 @@ LuaCallbacks Monster::makeMonsterCallbacks() {
     });
 
   callbacks.registerCallback("setAnimationParameter", [this](String name, Json value) {
-      m_scriptedAnimationParameters.set(move(name), move(value));
+      m_scriptedAnimationParameters.set(std::move(name), std::move(value));
     });
 
   return callbacks;
diff --git a/source/game/StarMonsterDatabase.cpp b/source/game/StarMonsterDatabase.cpp
index 4f6359f..395d873 100644
--- a/source/game/StarMonsterDatabase.cpp
+++ b/source/game/StarMonsterDatabase.cpp
@@ -288,11 +288,11 @@ Json MonsterDatabase::mergePartParameters(Json const& partParameterDescription,
             if (pair.second.type() == Json::Type::Array) {
               auto array = value.toArray();
               array.appendAll(pair.second.toArray());
-              value = move(array);
+              value = std::move(array);
             } else if (pair.second.type() == Json::Type::Object) {
               auto obj = value.toObject();
               obj.merge(pair.second.toObject(), true);
-              value = move(obj);
+              value = std::move(obj);
             }
           }
         }
@@ -319,7 +319,7 @@ Json MonsterDatabase::mergeFinalParameters(JsonArray const& parameters) {
           || pair.first == "baseSkills") {
         auto array = value.optArray().value();
         array.appendAll(pair.second.optArray().value());
-        value = move(array);
+        value = std::move(array);
       } else {
         value = jsonMerge(value, pair.second);
       }
diff --git a/source/game/StarMovementController.cpp b/source/game/StarMovementController.cpp
index a9b626f..88ac69f 100644
--- a/source/game/StarMovementController.cpp
+++ b/source/game/StarMovementController.cpp
@@ -721,7 +721,7 @@ void MovementController::forEachMovingCollision(RectF const& region, function<bo
     for (size_t i = 0; i < physicsEntity->movingCollisionCount(); ++i) {
       if (auto mc = physicsEntity->movingCollision(i)) {
         if (mc->categoryFilter.check(m_parameters.physicsEffectCategories.value())) {
-          PolyF poly = move(mc->collision);
+          PolyF poly = std::move(mc->collision);
           poly.translate(geometry.nearestTo(region.min(), mc->position));
           RectF polyBounds = poly.boundBox();
 
@@ -1055,7 +1055,7 @@ MovementController::CollisionSeparation MovementController::collisionSeparate(Li
 }
 
 void MovementController::updateParameters(MovementParameters parameters) {
-  m_parameters = move(parameters);
+  m_parameters = std::move(parameters);
   m_collisionPoly.set(*m_parameters.collisionPoly);
   m_mass.set(*m_parameters.mass);
   updatePositionInterpolators();
@@ -1106,7 +1106,7 @@ void MovementController::queryCollisions(RectF const& region) {
 
   forEachMovingCollision(region, [&](MovingCollisionId id, PhysicsMovingCollision mc, PolyF poly, RectF bounds) {
     CollisionPoly& collisionPoly = newCollisionPoly();
-    collisionPoly.poly = move(poly);
+    collisionPoly.poly = std::move(poly);
     collisionPoly.polyBounds = bounds;
     collisionPoly.sortPosition = collisionPoly.poly.center();
     collisionPoly.movingCollisionId = id;
diff --git a/source/game/StarNetPacketSocket.cpp b/source/game/StarNetPacketSocket.cpp
index e2bd629..48b2082 100644
--- a/source/game/StarNetPacketSocket.cpp
+++ b/source/game/StarNetPacketSocket.cpp
@@ -96,7 +96,7 @@ void LocalPacketSocket::sendPackets(List<PacketPtr> packets) {
     }
 #endif
 
-    outgoingPipe->queue.appendAll(move(packets));
+    outgoingPipe->queue.appendAll(std::move(packets));
   }
 }
 
@@ -120,12 +120,12 @@ bool LocalPacketSocket::readData() {
 }
 
 LocalPacketSocket::LocalPacketSocket(shared_ptr<Pipe> incomingPipe, weak_ptr<Pipe> outgoingPipe)
-  : m_incomingPipe(move(incomingPipe)), m_outgoingPipe(move(outgoingPipe)) {}
+  : m_incomingPipe(std::move(incomingPipe)), m_outgoingPipe(std::move(outgoingPipe)) {}
 
 TcpPacketSocketUPtr TcpPacketSocket::open(TcpSocketPtr socket) {
   socket->setNoDelay(true);
   socket->setNonBlocking(true);
-  return TcpPacketSocketUPtr(new TcpPacketSocket(move(socket)));
+  return TcpPacketSocketUPtr(new TcpPacketSocket(std::move(socket)));
 }
 
 bool TcpPacketSocket::isOpen() const {
@@ -217,7 +217,7 @@ List<PacketPtr> TcpPacketSocket::receivePackets() {
 
       m_incomingStats.mix(packetType, packetSize);
 
-      DataStreamBuffer packetStream(move(packetBytes));
+      DataStreamBuffer packetStream(std::move(packetBytes));
       do {
         PacketPtr packet = createPacket(packetType);
         packet->setCompressionMode(packetCompressed ? PacketCompressionMode::Enabled : PacketCompressionMode::Disabled);
@@ -225,7 +225,7 @@ List<PacketPtr> TcpPacketSocket::receivePackets() {
           packet->readLegacy(packetStream);
         else
           packet->read(packetStream);
-        packets.append(move(packet));
+        packets.append(std::move(packet));
       } while (!packetStream.atEnd());
 
       m_inputBuffer = ds.readBytes(ds.size() - ds.pos());
@@ -296,10 +296,10 @@ Maybe<PacketStats> TcpPacketSocket::outgoingStats() const {
 }
 
 TcpPacketSocket::TcpPacketSocket(TcpSocketPtr socket)
-  : m_socket(move(socket)) {}
+  : m_socket(std::move(socket)) {}
 
 P2PPacketSocketUPtr P2PPacketSocket::open(P2PSocketUPtr socket) {
-  return P2PPacketSocketUPtr(new P2PPacketSocket(move(socket)));
+  return P2PPacketSocketUPtr(new P2PPacketSocket(std::move(socket)));
 }
 
 bool P2PPacketSocket::isOpen() const {
@@ -357,7 +357,7 @@ List<PacketPtr> P2PPacketSocket::receivePackets() {
   List<PacketPtr> packets;
   try {
     for (auto& inputMessage : take(m_inputMessages)) {
-      DataStreamBuffer ds(move(inputMessage));
+      DataStreamBuffer ds(std::move(inputMessage));
 
       PacketType packetType = ds.read<PacketType>();
       bool packetCompressed = ds.read<bool>();
@@ -369,7 +369,7 @@ List<PacketPtr> P2PPacketSocket::receivePackets() {
 
       m_incomingStats.mix(packetType, packetSize);
 
-      DataStreamBuffer packetStream(move(packetBytes));
+      DataStreamBuffer packetStream(std::move(packetBytes));
       do {
         PacketPtr packet = createPacket(packetType);
         packet->setCompressionMode(packetCompressed ? PacketCompressionMode::Enabled : PacketCompressionMode::Disabled);
@@ -377,7 +377,7 @@ List<PacketPtr> P2PPacketSocket::receivePackets() {
           packet->readLegacy(packetStream);
         else
           packet->read(packetStream);
-        packets.append(move(packet));
+        packets.append(std::move(packet));
       } while (!packetStream.atEnd());
     }
   } catch (IOException const& e) {
@@ -430,6 +430,6 @@ Maybe<PacketStats> P2PPacketSocket::outgoingStats() const {
 }
 
 P2PPacketSocket::P2PPacketSocket(P2PSocketPtr socket)
-  : m_socket(move(socket)) {}
+  : m_socket(std::move(socket)) {}
 
 }
diff --git a/source/game/StarNetPackets.cpp b/source/game/StarNetPackets.cpp
index 0ccb66e..f787b1c 100644
--- a/source/game/StarNetPackets.cpp
+++ b/source/game/StarNetPackets.cpp
@@ -196,7 +196,7 @@ ConnectSuccessPacket::ConnectSuccessPacket() {}
 
 ConnectSuccessPacket::ConnectSuccessPacket(
     ConnectionId clientId, Uuid serverUuid, CelestialBaseInformation celestialInformation)
-  : clientId(clientId), serverUuid(move(serverUuid)), celestialInformation(move(celestialInformation)) {}
+  : clientId(clientId), serverUuid(std::move(serverUuid)), celestialInformation(std::move(celestialInformation)) {}
 
 void ConnectSuccessPacket::read(DataStream& ds) {
   ds.vuread(clientId);
@@ -212,7 +212,7 @@ void ConnectSuccessPacket::write(DataStream& ds) const {
 
 ConnectFailurePacket::ConnectFailurePacket() {}
 
-ConnectFailurePacket::ConnectFailurePacket(String reason) : reason(move(reason)) {}
+ConnectFailurePacket::ConnectFailurePacket(String reason) : reason(std::move(reason)) {}
 
 void ConnectFailurePacket::read(DataStream& ds) {
   ds.read(reason);
@@ -262,7 +262,7 @@ void UniverseTimeUpdatePacket::write(DataStream& ds) const {
 
 CelestialResponsePacket::CelestialResponsePacket() {}
 
-CelestialResponsePacket::CelestialResponsePacket(List<CelestialResponse> responses) : responses(move(responses)) {}
+CelestialResponsePacket::CelestialResponsePacket(List<CelestialResponse> responses) : responses(std::move(responses)) {}
 
 void CelestialResponsePacket::read(DataStream& ds) {
   ds.read(responses);
@@ -275,7 +275,7 @@ void CelestialResponsePacket::write(DataStream& ds) const {
 PlayerWarpResultPacket::PlayerWarpResultPacket() : warpActionInvalid(false) {}
 
 PlayerWarpResultPacket::PlayerWarpResultPacket(bool success, WarpAction warpAction, bool warpActionInvalid)
-  : success(success), warpAction(move(warpAction)), warpActionInvalid(warpActionInvalid) {}
+  : success(success), warpAction(std::move(warpAction)), warpActionInvalid(warpActionInvalid) {}
 
 void PlayerWarpResultPacket::read(DataStream& ds) {
   ds.read(success);
@@ -304,7 +304,7 @@ void PlanetTypeUpdatePacket::write(DataStream& ds) const {
 
 PausePacket::PausePacket() {}
 
-PausePacket::PausePacket(bool pause) : pause(move(pause)) {}
+PausePacket::PausePacket(bool pause) : pause(std::move(pause)) {}
 
 void PausePacket::read(DataStream& ds) {
   ds.read(pause);
@@ -337,9 +337,9 @@ ClientConnectPacket::ClientConnectPacket() {}
 ClientConnectPacket::ClientConnectPacket(ByteArray assetsDigest, bool allowAssetsMismatch, Uuid playerUuid,
     String playerName, String playerSpecies, WorldChunks shipChunks, ShipUpgrades shipUpgrades,
     bool introComplete, String account)
-  : assetsDigest(move(assetsDigest)), allowAssetsMismatch(allowAssetsMismatch), playerUuid(move(playerUuid)),
-    playerName(move(playerName)), playerSpecies(move(playerSpecies)), shipChunks(move(shipChunks)),
-    shipUpgrades(move(shipUpgrades)), introComplete(move(introComplete)), account(move(account)) {}
+  : assetsDigest(std::move(assetsDigest)), allowAssetsMismatch(allowAssetsMismatch), playerUuid(std::move(playerUuid)),
+    playerName(std::move(playerName)), playerSpecies(std::move(playerSpecies)), shipChunks(std::move(shipChunks)),
+    shipUpgrades(std::move(shipUpgrades)), introComplete(std::move(introComplete)), account(std::move(account)) {}
 
 void ClientConnectPacket::read(DataStream& ds) {
   ds.read(assetsDigest);
@@ -391,7 +391,7 @@ void HandshakeResponsePacket::write(DataStream& ds) const {
 
 PlayerWarpPacket::PlayerWarpPacket() {}
 
-PlayerWarpPacket::PlayerWarpPacket(WarpAction action, bool deploy) : action(move(action)), deploy(move(deploy)) {}
+PlayerWarpPacket::PlayerWarpPacket(WarpAction action, bool deploy) : action(std::move(action)), deploy(std::move(deploy)) {}
 
 void PlayerWarpPacket::read(DataStream& ds) {
   ds.read(action);
@@ -405,7 +405,7 @@ void PlayerWarpPacket::write(DataStream& ds) const {
 
 FlyShipPacket::FlyShipPacket() {}
 
-FlyShipPacket::FlyShipPacket(Vec3I system, SystemLocation location) : system(move(system)), location(move(location)) {}
+FlyShipPacket::FlyShipPacket(Vec3I system, SystemLocation location) : system(std::move(system)), location(std::move(location)) {}
 
 void FlyShipPacket::read(DataStream& ds) {
   ds.read(system);
@@ -419,7 +419,7 @@ void FlyShipPacket::write(DataStream& ds) const {
 
 ChatSendPacket::ChatSendPacket() : sendMode(ChatSendMode::Broadcast) {}
 
-ChatSendPacket::ChatSendPacket(String text, ChatSendMode sendMode) : text(move(text)), sendMode(sendMode) {}
+ChatSendPacket::ChatSendPacket(String text, ChatSendMode sendMode) : text(std::move(text)), sendMode(sendMode) {}
 
 void ChatSendPacket::read(DataStream& ds) {
   ds.read(text);
@@ -433,7 +433,7 @@ void ChatSendPacket::write(DataStream& ds) const {
 
 CelestialRequestPacket::CelestialRequestPacket() {}
 
-CelestialRequestPacket::CelestialRequestPacket(List<CelestialRequest> requests) : requests(move(requests)) {}
+CelestialRequestPacket::CelestialRequestPacket(List<CelestialRequest> requests) : requests(std::move(requests)) {}
 
 void CelestialRequestPacket::read(DataStream& ds) {
   ds.read(requests);
@@ -445,7 +445,7 @@ void CelestialRequestPacket::write(DataStream& ds) const {
 
 ClientContextUpdatePacket::ClientContextUpdatePacket() {}
 
-ClientContextUpdatePacket::ClientContextUpdatePacket(ByteArray updateData) : updateData(move(updateData)) {}
+ClientContextUpdatePacket::ClientContextUpdatePacket(ByteArray updateData) : updateData(std::move(updateData)) {}
 
 void ClientContextUpdatePacket::read(DataStream& ds) {
   ds.read(updateData);
@@ -525,7 +525,7 @@ void WorldParametersUpdatePacket::write(DataStream& ds) const {
 
 CentralStructureUpdatePacket::CentralStructureUpdatePacket() {}
 
-CentralStructureUpdatePacket::CentralStructureUpdatePacket(Json structureData) : structureData(move(structureData)) {}
+CentralStructureUpdatePacket::CentralStructureUpdatePacket(Json structureData) : structureData(std::move(structureData)) {}
 
 void CentralStructureUpdatePacket::read(DataStream& ds) {
   ds.read(structureData);
@@ -639,7 +639,7 @@ void GiveItemPacket::write(DataStream& ds) const {
 EnvironmentUpdatePacket::EnvironmentUpdatePacket() {}
 
 EnvironmentUpdatePacket::EnvironmentUpdatePacket(ByteArray skyDelta, ByteArray weatherDelta)
-  : skyDelta(move(skyDelta)), weatherDelta(move(weatherDelta)) {}
+  : skyDelta(std::move(skyDelta)), weatherDelta(std::move(weatherDelta)) {}
 
 void EnvironmentUpdatePacket::read(DataStream& ds) {
   ds.read(skyDelta);
@@ -670,7 +670,7 @@ DamageTileGroupPacket::DamageTileGroupPacket() : layer(TileLayer::Foreground) {}
 
 DamageTileGroupPacket::DamageTileGroupPacket(
     List<Vec2I> tilePositions, TileLayer layer, Vec2F sourcePosition, TileDamage tileDamage, Maybe<EntityId> sourceEntity)
-  : tilePositions(move(tilePositions)), layer(layer), sourcePosition(sourcePosition), tileDamage(move(tileDamage)), sourceEntity(move(sourceEntity)) {}
+  : tilePositions(std::move(tilePositions)), layer(layer), sourcePosition(sourcePosition), tileDamage(std::move(tileDamage)), sourceEntity(std::move(sourceEntity)) {}
 
 void DamageTileGroupPacket::read(DataStream& ds) {
   ds.readContainer(tilePositions);
@@ -691,7 +691,7 @@ void DamageTileGroupPacket::write(DataStream& ds) const {
 CollectLiquidPacket::CollectLiquidPacket() {}
 
 CollectLiquidPacket::CollectLiquidPacket(List<Vec2I> tilePositions, LiquidId liquidId)
-  : tilePositions(move(tilePositions)), liquidId(liquidId) {}
+  : tilePositions(std::move(tilePositions)), liquidId(liquidId) {}
 
 void CollectLiquidPacket::read(DataStream& ds) {
   ds.readContainer(tilePositions);
@@ -720,7 +720,7 @@ void RequestDropPacket::write(DataStream& ds) const {
 SpawnEntityPacket::SpawnEntityPacket() {}
 
 SpawnEntityPacket::SpawnEntityPacket(EntityType entityType, ByteArray storeData, ByteArray firstNetState)
-  : entityType(entityType), storeData(move(storeData)), firstNetState(move(firstNetState)) {}
+  : entityType(entityType), storeData(std::move(storeData)), firstNetState(std::move(firstNetState)) {}
 
 void SpawnEntityPacket::read(DataStream& ds) {
   ds.read(entityType);
@@ -772,7 +772,7 @@ EntityCreatePacket::EntityCreatePacket() {
 
 ServerDisconnectPacket::ServerDisconnectPacket() {}
 
-ServerDisconnectPacket::ServerDisconnectPacket(String reason) : reason(move(reason)) {}
+ServerDisconnectPacket::ServerDisconnectPacket(String reason) : reason(std::move(reason)) {}
 
 void ServerDisconnectPacket::read(DataStream& ds) {
   ds.read(reason);
@@ -830,7 +830,7 @@ void WorldClientStateUpdatePacket::write(DataStream& ds) const {
 FindUniqueEntityPacket::FindUniqueEntityPacket() {}
 
 FindUniqueEntityPacket::FindUniqueEntityPacket(String uniqueEntityId)
-  : uniqueEntityId(move(uniqueEntityId)) {}
+  : uniqueEntityId(std::move(uniqueEntityId)) {}
 
 void FindUniqueEntityPacket::read(DataStream& ds) {
   ds.read(uniqueEntityId);
@@ -865,7 +865,7 @@ void PingPacket::write(DataStream& ds) const {
 }
 
 EntityCreatePacket::EntityCreatePacket(EntityType entityType, ByteArray storeData, ByteArray firstNetState, EntityId entityId)
-  : entityType(entityType), storeData(move(storeData)), firstNetState(move(firstNetState)), entityId(entityId) {}
+  : entityType(entityType), storeData(std::move(storeData)), firstNetState(std::move(firstNetState)), entityId(entityId) {}
 
 void EntityCreatePacket::read(DataStream& ds) {
   ds.read(entityType);
@@ -906,7 +906,7 @@ EntityDestroyPacket::EntityDestroyPacket() {
 }
 
 EntityDestroyPacket::EntityDestroyPacket(EntityId entityId, ByteArray finalNetState, bool death)
-  : entityId(entityId), finalNetState(move(finalNetState)), death(death) {}
+  : entityId(entityId), finalNetState(std::move(finalNetState)), death(death) {}
 
 void EntityDestroyPacket::read(DataStream& ds) {
   ds.viread(entityId);
@@ -922,7 +922,7 @@ void EntityDestroyPacket::write(DataStream& ds) const {
 
 HitRequestPacket::HitRequestPacket() {}
 
-HitRequestPacket::HitRequestPacket(RemoteHitRequest remoteHitRequest) : remoteHitRequest(move(remoteHitRequest)) {}
+HitRequestPacket::HitRequestPacket(RemoteHitRequest remoteHitRequest) : remoteHitRequest(std::move(remoteHitRequest)) {}
 
 void HitRequestPacket::read(DataStream& ds) {
   ds.read(remoteHitRequest);
@@ -935,7 +935,7 @@ void HitRequestPacket::write(DataStream& ds) const {
 DamageRequestPacket::DamageRequestPacket() {}
 
 DamageRequestPacket::DamageRequestPacket(RemoteDamageRequest remoteDamageRequest)
-  : remoteDamageRequest(move(remoteDamageRequest)) {}
+  : remoteDamageRequest(std::move(remoteDamageRequest)) {}
 
 void DamageRequestPacket::read(DataStream& ds) {
   ds.read(remoteDamageRequest);
@@ -948,7 +948,7 @@ void DamageRequestPacket::write(DataStream& ds) const {
 DamageNotificationPacket::DamageNotificationPacket() {}
 
 DamageNotificationPacket::DamageNotificationPacket(RemoteDamageNotification remoteDamageNotification)
-  : remoteDamageNotification(move(remoteDamageNotification)) {}
+  : remoteDamageNotification(std::move(remoteDamageNotification)) {}
 
 void DamageNotificationPacket::read(DataStream& ds) {
   ds.read(remoteDamageNotification);
@@ -961,7 +961,7 @@ void DamageNotificationPacket::write(DataStream& ds) const {
 EntityMessagePacket::EntityMessagePacket() {}
 
 EntityMessagePacket::EntityMessagePacket(Variant<EntityId, String> entityId, String message, JsonArray args, Uuid uuid, ConnectionId fromConnection)
-  : entityId(entityId), message(move(message)), args(move(args)), uuid(uuid), fromConnection(fromConnection) {}
+  : entityId(entityId), message(std::move(message)), args(std::move(args)), uuid(uuid), fromConnection(fromConnection) {}
 
 void EntityMessagePacket::read(DataStream& ds) {
   ds.read(entityId);
@@ -982,7 +982,7 @@ void EntityMessagePacket::write(DataStream& ds) const {
 EntityMessageResponsePacket::EntityMessageResponsePacket() {}
 
 EntityMessageResponsePacket::EntityMessageResponsePacket(Either<String, Json> response, Uuid uuid)
-  : response(move(response)), uuid(uuid) {}
+  : response(std::move(response)), uuid(uuid) {}
 
 void EntityMessageResponsePacket::read(DataStream& ds) {
   ds.read(response);
@@ -1025,7 +1025,7 @@ void UpdateTileProtectionPacket::write(DataStream& ds) const {
 SetDungeonGravityPacket::SetDungeonGravityPacket() {}
 
 SetDungeonGravityPacket::SetDungeonGravityPacket(DungeonId dungeonId, Maybe<float> gravity)
-  : dungeonId(move(dungeonId)), gravity(move(gravity)) {}
+  : dungeonId(std::move(dungeonId)), gravity(std::move(gravity)) {}
 
 void SetDungeonGravityPacket::read(DataStream& ds) {
   ds.read(dungeonId);
@@ -1040,7 +1040,7 @@ void SetDungeonGravityPacket::write(DataStream& ds) const {
 SetDungeonBreathablePacket::SetDungeonBreathablePacket() {}
 
 SetDungeonBreathablePacket::SetDungeonBreathablePacket(DungeonId dungeonId, Maybe<bool> breathable)
-  : dungeonId(move(dungeonId)), breathable(move(breathable)) {}
+  : dungeonId(std::move(dungeonId)), breathable(std::move(breathable)) {}
 
 void SetDungeonBreathablePacket::read(DataStream& ds) {
   ds.read(dungeonId);
@@ -1069,7 +1069,7 @@ void SetPlayerStartPacket::write(DataStream& ds) const {
 FindUniqueEntityResponsePacket::FindUniqueEntityResponsePacket() {}
 
 FindUniqueEntityResponsePacket::FindUniqueEntityResponsePacket(String uniqueEntityId, Maybe<Vec2F> entityPosition)
-  : uniqueEntityId(move(uniqueEntityId)), entityPosition(move(entityPosition)) {}
+  : uniqueEntityId(std::move(uniqueEntityId)), entityPosition(std::move(entityPosition)) {}
 
 void FindUniqueEntityResponsePacket::read(DataStream& ds) {
   ds.read(uniqueEntityId);
@@ -1108,7 +1108,7 @@ void StepUpdatePacket::write(DataStream& ds) const {
 SystemWorldStartPacket::SystemWorldStartPacket() {}
 
 SystemWorldStartPacket::SystemWorldStartPacket(Vec3I location, List<ByteArray> objectStores, List<ByteArray> shipStores, pair<Uuid, SystemLocation> clientShip)
-  : location(move(location)), objectStores(move(objectStores)), shipStores(move(shipStores)), clientShip(move(clientShip)) {}
+  : location(std::move(location)), objectStores(std::move(objectStores)), shipStores(std::move(shipStores)), clientShip(std::move(clientShip)) {}
 
 void SystemWorldStartPacket::read(DataStream& ds) {
   ds.read(location);
@@ -1127,7 +1127,7 @@ void SystemWorldStartPacket::write(DataStream& ds) const {
 SystemWorldUpdatePacket::SystemWorldUpdatePacket() {}
 
 SystemWorldUpdatePacket::SystemWorldUpdatePacket(HashMap<Uuid, ByteArray> objectUpdates, HashMap<Uuid, ByteArray> shipUpdates)
-  : objectUpdates(move(objectUpdates)), shipUpdates(move(shipUpdates)) {}
+  : objectUpdates(std::move(objectUpdates)), shipUpdates(std::move(shipUpdates)) {}
 
 void SystemWorldUpdatePacket::read(DataStream& ds) {
   ds.read(objectUpdates);
@@ -1141,7 +1141,7 @@ void SystemWorldUpdatePacket::write(DataStream& ds) const {
 
 SystemObjectCreatePacket::SystemObjectCreatePacket() {}
 
-SystemObjectCreatePacket::SystemObjectCreatePacket(ByteArray objectStore) : objectStore(move(objectStore)) {}
+SystemObjectCreatePacket::SystemObjectCreatePacket(ByteArray objectStore) : objectStore(std::move(objectStore)) {}
 
 void SystemObjectCreatePacket::read(DataStream& ds) {
   ds.read(objectStore);
@@ -1153,7 +1153,7 @@ void SystemObjectCreatePacket::write(DataStream& ds) const {
 
 SystemObjectDestroyPacket::SystemObjectDestroyPacket() {}
 
-SystemObjectDestroyPacket::SystemObjectDestroyPacket(Uuid objectUuid) : objectUuid(move(objectUuid)) {}
+SystemObjectDestroyPacket::SystemObjectDestroyPacket(Uuid objectUuid) : objectUuid(std::move(objectUuid)) {}
 
 void SystemObjectDestroyPacket::read(DataStream& ds) {
   ds.read(objectUuid);
@@ -1165,7 +1165,7 @@ void SystemObjectDestroyPacket::write(DataStream& ds) const {
 
 SystemShipCreatePacket::SystemShipCreatePacket() {}
 
-SystemShipCreatePacket::SystemShipCreatePacket(ByteArray shipStore) : shipStore(move(shipStore)) {}
+SystemShipCreatePacket::SystemShipCreatePacket(ByteArray shipStore) : shipStore(std::move(shipStore)) {}
 
 void SystemShipCreatePacket::read(DataStream& ds) {
   ds.read(shipStore);
@@ -1177,7 +1177,7 @@ void SystemShipCreatePacket::write(DataStream& ds) const {
 
 SystemShipDestroyPacket::SystemShipDestroyPacket() {}
 
-SystemShipDestroyPacket::SystemShipDestroyPacket(Uuid shipUuid) : shipUuid(move(shipUuid)) {}
+SystemShipDestroyPacket::SystemShipDestroyPacket(Uuid shipUuid) : shipUuid(std::move(shipUuid)) {}
 
 void SystemShipDestroyPacket::read(DataStream& ds) {
   ds.read(shipUuid);
@@ -1190,7 +1190,7 @@ void SystemShipDestroyPacket::write(DataStream& ds) const {
 SystemObjectSpawnPacket::SystemObjectSpawnPacket() {}
 
 SystemObjectSpawnPacket::SystemObjectSpawnPacket(String typeName, Uuid uuid, Maybe<Vec2F> position, JsonObject parameters)
-  : typeName(move(typeName)), uuid(move(uuid)), position(move(position)), parameters(move(parameters)) {}
+  : typeName(std::move(typeName)), uuid(std::move(uuid)), position(std::move(position)), parameters(std::move(parameters)) {}
 
 void SystemObjectSpawnPacket::read(DataStream& ds) {
   ds.read(typeName);
diff --git a/source/game/StarNetworkedAnimator.cpp b/source/game/StarNetworkedAnimator.cpp
index 6f74f02..f64d293 100644
--- a/source/game/StarNetworkedAnimator.cpp
+++ b/source/game/StarNetworkedAnimator.cpp
@@ -108,7 +108,7 @@ NetworkedAnimator::NetworkedAnimator(Json config, String relativePath) : Network
   for (auto const& pair : config.get("rotationGroups", JsonObject()).iterateObject()) {
     String rotationGroupName = pair.first;
     Json rotationGroupConfig = pair.second;
-    RotationGroup& rotationGroup = m_rotationGroups[move(rotationGroupName)];
+    RotationGroup& rotationGroup = m_rotationGroups[std::move(rotationGroupName)];
     rotationGroup.angularVelocity = rotationGroupConfig.getFloat("angularVelocity", 0.0f);
     rotationGroup.rotationCenter = jsonToVec2F(rotationGroupConfig.get("rotationCenter", JsonArray{0, 0}));
   }
@@ -117,7 +117,7 @@ NetworkedAnimator::NetworkedAnimator(Json config, String relativePath) : Network
     String particleEmitterName = pair.first;
     Json particleEmitterConfig = pair.second;
 
-    ParticleEmitter& emitter = m_particleEmitters[move(particleEmitterName)];
+    ParticleEmitter& emitter = m_particleEmitters[std::move(particleEmitterName)];
     emitter.emissionRate.set(particleEmitterConfig.getFloat("emissionRate", 1.0f));
     emitter.emissionRateVariance = particleEmitterConfig.getFloat("emissionRateVariance", 0.0f);
     emitter.offsetRegion.set(particleEmitterConfig.opt("offsetRegion").apply(jsonToRectF).value(RectF::null()));
@@ -147,7 +147,7 @@ NetworkedAnimator::NetworkedAnimator(Json config, String relativePath) : Network
     String lightName = pair.first;
     Json lightConfig = pair.second;
 
-    Light& light = m_lights[move(lightName)];
+    Light& light = m_lights[std::move(lightName)];
     light.active.set(lightConfig.getBool("active", true));
     auto lightPosition = lightConfig.opt("position").apply(jsonToVec2F).value();
     light.xPosition.set(lightPosition[0]);
@@ -177,7 +177,7 @@ NetworkedAnimator::NetworkedAnimator(Json config, String relativePath) : Network
   for (auto const& pair : config.get("sounds", JsonObject()).iterateObject()) {
     String soundName = pair.first;
     Json soundConfig = pair.second;
-    Sound& sound = m_sounds[move(soundName)];
+    Sound& sound = m_sounds[std::move(soundName)];
     if (soundConfig.isType(Json::Type::Array)) {
       sound.rangeMultiplier = 1.0f;
       sound.soundPool.set(jsonToStringList(soundConfig).transformed(bind(&AssetPath::relativeTo, m_relativePath, _1)));
@@ -231,7 +231,7 @@ NetworkedAnimator::NetworkedAnimator(Json config, String relativePath) : Network
 }
 
 NetworkedAnimator::NetworkedAnimator(NetworkedAnimator&& animator) {
-  operator=(move(animator));
+  operator=(std::move(animator));
 }
 
 NetworkedAnimator::NetworkedAnimator(NetworkedAnimator const& animator) {
@@ -239,23 +239,23 @@ NetworkedAnimator::NetworkedAnimator(NetworkedAnimator const& animator) {
 }
 
 NetworkedAnimator& NetworkedAnimator::operator=(NetworkedAnimator&& animator) {
-  m_relativePath = move(animator.m_relativePath);
-  m_animatedParts = move(animator.m_animatedParts);
-  m_stateInfo = move(animator.m_stateInfo);
-  m_transformationGroups = move(animator.m_transformationGroups);
-  m_rotationGroups = move(animator.m_rotationGroups);
-  m_particleEmitters = move(animator.m_particleEmitters);
-  m_lights = move(animator.m_lights);
-  m_sounds = move(animator.m_sounds);
-  m_effects = move(animator.m_effects);
-  m_processingDirectives = move(animator.m_processingDirectives);
-  m_zoom = move(animator.m_zoom);
-  m_flipped = move(animator.m_flipped);
-  m_flippedRelativeCenterLine = move(animator.m_flippedRelativeCenterLine);
-  m_animationRate = move(animator.m_animationRate);
-  m_globalTags = move(animator.m_globalTags);
-  m_partTags = move(animator.m_partTags);
-  m_cachedPartDrawables = move(animator.m_cachedPartDrawables);
+  m_relativePath = std::move(animator.m_relativePath);
+  m_animatedParts = std::move(animator.m_animatedParts);
+  m_stateInfo = std::move(animator.m_stateInfo);
+  m_transformationGroups = std::move(animator.m_transformationGroups);
+  m_rotationGroups = std::move(animator.m_rotationGroups);
+  m_particleEmitters = std::move(animator.m_particleEmitters);
+  m_lights = std::move(animator.m_lights);
+  m_sounds = std::move(animator.m_sounds);
+  m_effects = std::move(animator.m_effects);
+  m_processingDirectives = std::move(animator.m_processingDirectives);
+  m_zoom = std::move(animator.m_zoom);
+  m_flipped = std::move(animator.m_flipped);
+  m_flippedRelativeCenterLine = std::move(animator.m_flippedRelativeCenterLine);
+  m_animationRate = std::move(animator.m_animationRate);
+  m_globalTags = std::move(animator.m_globalTags);
+  m_partTags = std::move(animator.m_partTags);
+  m_cachedPartDrawables = std::move(animator.m_cachedPartDrawables);
 
   setupNetStates();
 
@@ -380,7 +380,7 @@ Maybe<PolyF> NetworkedAnimator::partPoly(String const& partName, String const& p
 }
 
 void NetworkedAnimator::setGlobalTag(String tagName, String tagValue) {
-  m_globalTags.set(move(tagName), move(tagValue));
+  m_globalTags.set(std::move(tagName), std::move(tagValue));
 }
 
 void NetworkedAnimator::removeGlobalTag(String const& tagName) {
@@ -393,7 +393,7 @@ String const* NetworkedAnimator::globalTagPtr(String const& tagName) const {
 
 
 void NetworkedAnimator::setPartTag(String const& partType, String tagName, String tagValue) {
-  m_partTags[partType].set(move(tagName), move(tagValue));
+  m_partTags[partType].set(std::move(tagName), std::move(tagValue));
 }
 
 void NetworkedAnimator::setProcessingDirectives(Directives const& directives) {
@@ -528,7 +528,7 @@ bool NetworkedAnimator::hasSound(String const& soundName) const {
 }
 
 void NetworkedAnimator::setSoundPool(String const& soundName, StringList soundPool) {
-  m_sounds.get(soundName).soundPool.set(move(soundPool));
+  m_sounds.get(soundName).soundPool.set(std::move(soundPool));
 }
 
 void NetworkedAnimator::setSoundPosition(String const& soundName, Vec2F const& position) {
@@ -568,7 +568,7 @@ void NetworkedAnimator::setEffectEnabled(String const& effect, bool enabled) {
 List<Drawable> NetworkedAnimator::drawables(Vec2F const& position) const {
   List<Drawable> drawables;
   for (auto& p : drawablesWithZLevel(position))
-    drawables.append(move(p.first));
+    drawables.append(std::move(p.first));
   return drawables;
 }
 
@@ -655,10 +655,10 @@ List<pair<Drawable, float>> NetworkedAnimator::drawablesWithZLevel(Vec2F const&
 
           Drawable drawable = Drawable::makeImage(!relativeImage.empty() ? relativeImage : usedImage, 1.0f / TilePixels, centered, Vec2F());
           if (find == m_cachedPartDrawables.end())
-            find = m_cachedPartDrawables.emplace(partName, std::pair{ hash, move(drawable) }).first;
+            find = m_cachedPartDrawables.emplace(partName, std::pair{ hash, std::move(drawable) }).first;
           else {
             find->second.first = hash;
-            find->second.second = move(drawable);
+            find->second.second = std::move(drawable);
           }
         }
 
@@ -671,7 +671,7 @@ List<pair<Drawable, float>> NetworkedAnimator::drawablesWithZLevel(Vec2F const&
         drawable.fullbright = fullbright;
         drawable.translate(position);
 
-        drawables.append({move(drawable), zLevel});
+        drawables.append({std::move(drawable), zLevel});
       }
         
       baseProcessingDirectives.resize(originalDirectivesSize);
@@ -750,7 +750,7 @@ void NetworkedAnimator::update(float dt, DynamicTarget* dynamicTarget) {
 
         bool changedPersistentSound = persistentSound != activePersistentSound.sound;
         if (changedPersistentSound || !activePersistentSound.audio) {
-          activePersistentSound.sound = move(persistentSound);
+          activePersistentSound.sound = std::move(persistentSound);
           if (activePersistentSound.audio)
             activePersistentSound.audio->stop(activePersistentSound.stopRampTime);
 
@@ -781,7 +781,7 @@ void NetworkedAnimator::update(float dt, DynamicTarget* dynamicTarget) {
 
         bool changedImmediateSound = immediateSound != activeImmediateSound.sound;
         if (changedImmediateSound) {
-          activeImmediateSound.sound = move(immediateSound);
+          activeImmediateSound.sound = std::move(immediateSound);
           if (!immediateSoundFile.empty()) {
             activeImmediateSound.audio = make_shared<AudioInstance>(*Root::singleton().assets()->audio(immediateSoundFile));
             activeImmediateSound.audio->setRangeMultiplier(activeState.properties.value("immediateSoundRangeMultiplier", 1.0f).toFloat());
@@ -843,7 +843,7 @@ void NetworkedAnimator::update(float dt, DynamicTarget* dynamicTarget) {
           particle.rotation += Constants::pi;
         }
 
-        dynamicTarget->pendingParticles.append(move(particle));
+        dynamicTarget->pendingParticles.append(std::move(particle));
       }
     };
 
@@ -916,7 +916,7 @@ void NetworkedAnimator::update(float dt, DynamicTarget* dynamicTarget) {
             sound->setVolume(soundEntry.volumeTarget.get(), soundEntry.volumeRampTime.get());
             sound->setPitchMultiplier(soundEntry.pitchMultiplierTarget.get(), soundEntry.pitchMultiplierRampTime.get());
             dynamicTarget->independentSounds[soundName].append(sound);
-            dynamicTarget->pendingAudios.append(move(sound));
+            dynamicTarget->pendingAudios.append(std::move(sound));
           }
         }
       }
diff --git a/source/game/StarNpc.cpp b/source/game/StarNpc.cpp
index af0bedb..3f15217 100644
--- a/source/game/StarNpc.cpp
+++ b/source/game/StarNpc.cpp
@@ -271,7 +271,7 @@ pair<ByteArray, uint64_t> Npc::writeNetState(uint64_t fromVersion) {
 }
 
 void Npc::readNetState(ByteArray data, float interpolationTime) {
-  m_netGroup.readNetState(move(data), interpolationTime);
+  m_netGroup.readNetState(std::move(data), interpolationTime);
 }
 
 String Npc::description() const {
@@ -479,7 +479,7 @@ void Npc::render(RenderCallback* renderCallback) {
     drawable.translate(position());
     if (drawable.isImage())
       drawable.imagePart().addDirectivesGroup(m_statusController->parentDirectives(), true);
-    renderCallback->addDrawable(move(drawable), renderLayer);
+    renderCallback->addDrawable(std::move(drawable), renderLayer);
   }
 
   renderCallback->addDrawables(m_statusController->drawables(), renderLayer);
diff --git a/source/game/StarNpcDatabase.cpp b/source/game/StarNpcDatabase.cpp
index f7b14de..343702e 100644
--- a/source/game/StarNpcDatabase.cpp
+++ b/source/game/StarNpcDatabase.cpp
@@ -134,7 +134,7 @@ NpcVariant NpcDatabase::generateNpcVariant(
             }
           }
 
-          variant.items[itemSlotConfig.first] = move(item);
+          variant.items[itemSlotConfig.first] = std::move(item);
         }
       }
     }
diff --git a/source/game/StarObject.cpp b/source/game/StarObject.cpp
index 7457b5d..c56229e 100644
--- a/source/game/StarObject.cpp
+++ b/source/game/StarObject.cpp
@@ -155,8 +155,8 @@ void Object::init(World* world, EntityId entityId, EntityMode mode) {
     else
       colorDirectives = colorName.substr(colorEnd, suffixBegin - colorEnd);
 
-    m_colorSuffix = move(colorSuffix);
-    m_colorDirectives = move(colorDirectives);
+    m_colorSuffix = std::move(colorSuffix);
+    m_colorDirectives = std::move(colorDirectives);
   }
   else
     m_colorDirectives = m_colorSuffix = "";
@@ -293,7 +293,7 @@ pair<ByteArray, uint64_t> Object::writeNetState(uint64_t fromVersion) {
 }
 
 void Object::readNetState(ByteArray delta, float interpolationTime) {
-  m_netGroup.readNetState(move(delta), interpolationTime);
+  m_netGroup.readNetState(std::move(delta), interpolationTime);
 }
 
 Vec2I Object::tilePosition() const {
@@ -501,7 +501,7 @@ void Object::destroy(RenderCallback* renderCallback) {
 
   if (renderCallback && doSmash && !m_config->smashSoundOptions.empty()) {
     auto audio = make_shared<AudioInstance>(*Root::singleton().assets()->audio(Random::randFrom(m_config->smashSoundOptions)));
-    renderCallback->addAudios({move(audio)}, position());
+    renderCallback->addAudios({std::move(audio)}, position());
   }
 
   if (renderCallback && doSmash && !m_config->smashParticles.empty()) {
@@ -523,7 +523,7 @@ void Object::destroy(RenderCallback* renderCallback) {
           particle.flip = !particle.flip;
         }
         particle.translate(position() + volume().center());
-        particles.append(move(particle));
+        particles.append(std::move(particle));
       }
     }
     renderCallback->addParticles(particles);
@@ -680,7 +680,7 @@ void Object::readStoredData(Json const& diskStore) {
       List<WireConnection> connections;
       for (auto const& conn : inputNodes[i].getArray("connections"))
         connections.append(WireConnection{jsonToVec2I(conn.get(0)), (size_t)conn.get(1).toUInt()});
-      in.connections.set(move(connections));
+      in.connections.set(std::move(connections));
       in.state.set(inputNodes[i].getBool("state"));
     }
   }
@@ -692,7 +692,7 @@ void Object::readStoredData(Json const& diskStore) {
       List<WireConnection> connections;
       for (auto const& conn : outputNodes[i].getArray("connections"))
         connections.append(WireConnection{jsonToVec2I(conn.get(0)), (size_t)conn.get(1).toUInt()});
-      in.connections.set(move(connections));
+      in.connections.set(std::move(connections));
       in.state.set(outputNodes[i].getBool("state"));
     }
   }
@@ -707,7 +707,7 @@ Json Object::writeStoredData() const {
       connections.append(JsonArray{jsonFromVec2I(node.entityLocation), node.nodeIndex});
 
     inputNodes.append(JsonObject{
-        {"connections", move(connections)},
+        {"connections", std::move(connections)},
         {"state", in.state.get()}
       });
   }
@@ -720,7 +720,7 @@ Json Object::writeStoredData() const {
       connections.append(JsonArray{jsonFromVec2I(node.entityLocation), node.nodeIndex});
 
     outputNodes.append(JsonObject{
-        {"connections", move(connections)},
+        {"connections", std::move(connections)},
         {"state", in.state.get()}
       });
   }
@@ -732,8 +732,8 @@ Json Object::writeStoredData() const {
     {"direction", DirectionNames.getRight(m_direction.get())},
     {"scriptStorage", m_scriptComponent.getScriptStorage()},
     {"interactive", m_interactive.get()},
-    {"inputWireNodes", move(inputNodes)},
-    {"outputWireNodes", move(outputNodes)}
+    {"inputWireNodes", std::move(inputNodes)},
+    {"outputWireNodes", std::move(outputNodes)}
   };
 }
 
@@ -1028,11 +1028,11 @@ LuaCallbacks Object::makeObjectCallbacks() {
     });
 
   callbacks.registerCallback("setConfigParameter", [this](String key, Json value) {
-      m_parameters.set(move(key), move(value));
+      m_parameters.set(std::move(key), std::move(value));
     });
 
   callbacks.registerCallback("setAnimationParameter", [this](String key, Json value) {
-      m_scriptedAnimationParameters.set(move(key), move(value));
+      m_scriptedAnimationParameters.set(std::move(key), std::move(value));
     });
 
   callbacks.registerCallback("setMaterialSpaces", [this](Maybe<JsonArray> const& newSpaces) {
@@ -1241,7 +1241,7 @@ List<Drawable> Object::orientationDrawables(size_t orientationIndex) const {
       String imagePath = AssetPath::join(imagePart.image);
       if ((m_colorDirectives || !m_colorSuffix.empty()) && m_imageKeys.contains("color")) { // We had to leave color untouched despite separating its directives for server-side compatibility reasons, temporarily substr it in the image key
         String& color = m_imageKeys.find("color")->second;
-        String backup = move(color);
+        String backup = std::move(color);
         color = backup.substr(0, backup.find('?'));
 
         // backwards compatibility for this is really annoying, need to append text after the <color> tag to the last directive for a rare use-case
@@ -1252,7 +1252,7 @@ List<Drawable> Object::orientationDrawables(size_t orientationIndex) const {
         else
           imagePart.image = imagePath.replaceTags(m_imageKeys, true, "default");
 
-        color = move(backup);
+        color = std::move(backup);
 
         imagePart.image.directives = layer.imagePart().image.directives;
         if (m_colorDirectives)
@@ -1270,7 +1270,7 @@ List<Drawable> Object::orientationDrawables(size_t orientationIndex) const {
       if (orientation->flipImages)
         drawable.scale(Vec2F(-1, 1), drawable.boundBox(false).center() - drawable.position);
 
-      m_orientationDrawablesCache->second.append(move(drawable));
+      m_orientationDrawablesCache->second.append(std::move(drawable));
     }
   }
 
@@ -1311,7 +1311,7 @@ void Object::renderParticles(RenderCallback* renderCallback) {
         if (particleEmitter.placeInSpaces)
           particle.translate(Vec2F(Random::randFrom(orientation->spaces)) + Vec2F(0.5, 0.5));
         particle.translate(position());
-        renderCallback->addParticle(move(particle));
+        renderCallback->addParticle(std::move(particle));
         timer = GameTimer(1.0f / (particleEmitter.particleEmissionRate + Random::randf(-particleEmitter.particleEmissionRateVariance, particleEmitter.particleEmissionRateVariance)));
       }
     }
diff --git a/source/game/StarObjectDatabase.cpp b/source/game/StarObjectDatabase.cpp
index d886be8..68ec6a9 100644
--- a/source/game/StarObjectDatabase.cpp
+++ b/source/game/StarObjectDatabase.cpp
@@ -300,7 +300,7 @@ List<ObjectOrientationPtr> ObjectDatabase::parseOrientations(String const& path,
 
     orientation->touchDamageConfig = parseTouchDamage(path, orientationSettings);
 
-    res.append(move(orientation));
+    res.append(std::move(orientation));
   }
 
   return res;
@@ -584,7 +584,7 @@ List<Drawable> ObjectDatabase::cursorHintDrawables(World const* world, String co
       image = AssetPath::join(image).replaceTags(StringMap<String>(), true, "default");
       if (orientation->flipImages)
         drawable.scale(Vec2F(-1, 1), drawable.boundBox(false).center() - drawable.position);
-      drawables.append(move(drawable));
+      drawables.append(std::move(drawable));
     }
     Drawable::translateAll(drawables, Vec2F(position) + orientation->imagePosition);
   }
diff --git a/source/game/StarParallax.cpp b/source/game/StarParallax.cpp
index 8ebb391..2670699 100644
--- a/source/game/StarParallax.cpp
+++ b/source/game/StarParallax.cpp
@@ -69,7 +69,7 @@ void ParallaxLayer::addImageDirectives(Directives const& newDirectives) {
         dirString += newString;
       }
 
-      directives = move(dirString);
+      directives = std::move(dirString);
     }
     else
       directives = newDirectives;
diff --git a/source/game/StarParticleDatabase.cpp b/source/game/StarParticleDatabase.cpp
index bade6b5..04e0f46 100644
--- a/source/game/StarParticleDatabase.cpp
+++ b/source/game/StarParticleDatabase.cpp
@@ -47,7 +47,7 @@ ParticleVariantCreator ParticleDatabase::particleCreator(Json const& kindOrConfi
   } else {
     Particle particle(kindOrConfig.toObject(), relativePath);
     Particle variance(kindOrConfig.getObject("variance", {}), relativePath);
-    return makeParticleVariantCreator(move(particle), move(variance));
+    return makeParticleVariantCreator(std::move(particle), std::move(variance));
   }
 }
 
diff --git a/source/game/StarParticleManager.cpp b/source/game/StarParticleManager.cpp
index c19eab6..e4e028c 100644
--- a/source/game/StarParticleManager.cpp
+++ b/source/game/StarParticleManager.cpp
@@ -8,11 +8,11 @@ ParticleManager::ParticleManager(WorldGeometry const& worldGeometry, ClientTileS
   : m_worldGeometry(worldGeometry), m_undergroundLevel(0.0f), m_tileSectorArray(tileSectorArray) {}
 
 void ParticleManager::add(Particle particle) {
-  m_particles.push_back(move(particle));
+  m_particles.push_back(std::move(particle));
 }
 
 void ParticleManager::addParticles(List<Particle> particles) {
-  m_particles.appendAll(move(particles));
+  m_particles.appendAll(std::move(particles));
 }
 
 size_t ParticleManager::count() const {
@@ -88,11 +88,11 @@ void ParticleManager::update(float dt, RectF const& cullRegion, float wind) {
       trail.trail = false;
       trail.timeToLive = 0;
       trail.velocity = {};
-      m_nextParticles.append(move(trail));
+      m_nextParticles.append(std::move(trail));
     }
 
     if (!particle.dead())
-      m_nextParticles.append(move(particle));
+      m_nextParticles.append(std::move(particle));
   }
 
   m_particles.clear();
diff --git a/source/game/StarPlant.cpp b/source/game/StarPlant.cpp
index f26c73a..6f1dece 100644
--- a/source/game/StarPlant.cpp
+++ b/source/game/StarPlant.cpp
@@ -591,7 +591,7 @@ pair<ByteArray, uint64_t> Plant::writeNetState(uint64_t fromVersion) {
 }
 
 void Plant::readNetState(ByteArray data, float interpolationTime) {
-  m_netGroup.readNetState(move(data), interpolationTime);
+  m_netGroup.readNetState(std::move(data), interpolationTime);
 }
 
 void Plant::enableInterpolation(float extrapolationHint) {
@@ -758,7 +758,7 @@ void Plant::render(RenderCallback* renderCallback) {
       drawable.rotate(branchRotation(m_tilePosition[0], plantPiece.rotationOffset * 1.4f), plantPiece.offset + Vec2F(size) / 2.0f);
     }
     drawable.translate(position());
-    renderCallback->addDrawable(move(drawable), RenderLayerPlant);
+    renderCallback->addDrawable(std::move(drawable), RenderLayerPlant);
   }
 
   if (m_tileDamageEvent) {
@@ -780,7 +780,7 @@ void Plant::render(RenderCallback* renderCallback) {
         }
         particle.position = {m_tileDamageX + Random::randf(), m_tileDamageY + Random::randf()};
         particle.translate(position());
-        renderCallback->addParticle(move(particle));
+        renderCallback->addParticle(std::move(particle));
       }
       JsonArray damageTreeSoundOptions = m_stemDropConfig.get("sounds", JsonObject()).getArray("damageTree", JsonArray());
       if (damageTreeSoundOptions.size()) {
@@ -790,7 +790,7 @@ void Plant::render(RenderCallback* renderCallback) {
         auto audioInstance = make_shared<AudioInstance>(*assets->audio(sound.getString("file")));
         audioInstance->setPosition(pos);
         audioInstance->setVolume(sound.getFloat("volume", 1.0f));
-        renderCallback->addAudio(move(audioInstance));
+        renderCallback->addAudio(std::move(audioInstance));
       }
     }
   }
@@ -798,7 +798,7 @@ void Plant::render(RenderCallback* renderCallback) {
 
 void Plant::readPieces(ByteArray pieces) {
   if (!pieces.empty()) {
-    DataStreamBuffer ds(move(pieces));
+    DataStreamBuffer ds(std::move(pieces));
     ds.readContainer(m_pieces, [](DataStream& ds, PlantPiece& piece) {
         ds.read(piece.image);
         ds.read(piece.offset[0]);
diff --git a/source/game/StarPlantDrop.cpp b/source/game/StarPlantDrop.cpp
index 1c242b2..b739856 100644
--- a/source/game/StarPlantDrop.cpp
+++ b/source/game/StarPlantDrop.cpp
@@ -306,7 +306,7 @@ void PlantDrop::render(RenderCallback* renderCallback) {
           auto audioInstance = make_shared<AudioInstance>(*assets->audio(sound.getString("file")));
           audioInstance->setPosition(collisionRect().center() + position());
           audioInstance->setVolume(sound.getFloat("volume", 1.0f));
-          renderCallback->addAudio(move(audioInstance));
+          renderCallback->addAudio(std::move(audioInstance));
         }
       };
       playBreakSound(m_stemConfig);
@@ -332,7 +332,7 @@ void PlantDrop::render(RenderCallback* renderCallback) {
         auto audioInstance = make_shared<AudioInstance>(*assets->audio(sound.getString("file")));
         audioInstance->setPosition(collisionRect().center() + position());
         audioInstance->setVolume(sound.getFloat("volume", 1.0f));
-        renderCallback->addAudio(move(audioInstance));
+        renderCallback->addAudio(std::move(audioInstance));
       }
     };
     playHitSound(m_stemConfig);
@@ -353,7 +353,7 @@ void PlantDrop::render(RenderCallback* renderCallback) {
         drawable.scale(Vec2F(-1, 1));
       drawable.rotate(m_movementController.rotation());
       drawable.translate(position());
-      renderCallback->addDrawable(move(drawable), RenderLayerPlantDrop);
+      renderCallback->addDrawable(std::move(drawable), RenderLayerPlantDrop);
     }
   }
 }
@@ -363,7 +363,7 @@ pair<ByteArray, uint64_t> PlantDrop::writeNetState(uint64_t fromVersion) {
 }
 
 void PlantDrop::readNetState(ByteArray data, float interpolationTime) {
-  m_netGroup.readNetState(move(data), interpolationTime);
+  m_netGroup.readNetState(std::move(data), interpolationTime);
 }
 
 void PlantDrop::enableInterpolation(float extrapolationHint) {
diff --git a/source/game/StarPlatformerAStar.cpp b/source/game/StarPlatformerAStar.cpp
index c74802c..fbd873b 100644
--- a/source/game/StarPlatformerAStar.cpp
+++ b/source/game/StarPlatformerAStar.cpp
@@ -48,8 +48,8 @@ namespace PlatformerAStar {
     : m_world(world),
       m_searchFrom(searchFrom),
       m_searchTo(searchTo),
-      m_movementParams(move(movementParameters)),
-      m_searchParams(move(searchParameters)) {
+      m_movementParams(std::move(movementParameters)),
+      m_searchParams(std::move(searchParameters)) {
     initAStar();
   }
 
diff --git a/source/game/StarPlayer.cpp b/source/game/StarPlayer.cpp
index 3969646..ebadf20 100644
--- a/source/game/StarPlayer.cpp
+++ b/source/game/StarPlayer.cpp
@@ -274,7 +274,7 @@ ClientContextPtr Player::clientContext() const {
 }
 
 void Player::setClientContext(ClientContextPtr clientContext) {
-  m_clientContext = move(clientContext);
+  m_clientContext = std::move(clientContext);
   if (m_clientContext)
     m_universeMap->setServerUuid(m_clientContext->serverUuid());
 }
@@ -380,7 +380,7 @@ List<Drawable> Player::drawables() const {
               drawable.imagePart().addDirectives(*directives, true);
           }
         }
-        drawables.append(move(drawable));
+        drawables.append(std::move(drawable));
       }
     }
     drawables.appendAll(m_techController->frontDrawables());
@@ -1079,14 +1079,14 @@ void Player::render(RenderCallback* renderCallback) {
       auto landingNoise = make_shared<AudioInstance>(*footstepAudio);
       landingNoise->setPosition(position() + feetOffset());
       landingNoise->setVolume(m_landingVolume);
-      renderCallback->addAudio(move(landingNoise));
+      renderCallback->addAudio(std::move(landingNoise));
     }
 
     if (m_footstepPending) {
       auto stepNoise = make_shared<AudioInstance>(*footstepAudio);
       stepNoise->setPosition(position() + feetOffset());
       stepNoise->setVolume(1 - Random::randf(0, m_footstepVolumeVariance));
-      renderCallback->addAudio(move(stepNoise));
+      renderCallback->addAudio(std::move(stepNoise));
     }
   } else {
     m_footstepTimer = m_config->footstepTiming;
@@ -1105,7 +1105,7 @@ void Player::render(RenderCallback* renderCallback) {
     audio->setVolume(get<1>(p));
     audio->setPitchMultiplier(get<2>(p));
     audio->setPosition(position());
-    renderCallback->addAudio(move(audio));
+    renderCallback->addAudio(std::move(audio));
   }
 
   auto loungeAnchor = as<LoungeAnchor>(m_movementController->entityAnchor());
@@ -1594,7 +1594,7 @@ pair<ByteArray, uint64_t> Player::writeNetState(uint64_t fromVersion) {
 }
 
 void Player::readNetState(ByteArray data, float interpolationTime) {
-  m_netGroup.readNetState(move(data), interpolationTime);
+  m_netGroup.readNetState(std::move(data), interpolationTime);
 }
 
 void Player::enableInterpolation(float) {
@@ -2003,7 +2003,7 @@ ShipUpgrades Player::shipUpgrades() {
 }
 
 void Player::setShipUpgrades(ShipUpgrades shipUpgrades) {
-  m_shipUpgrades = move(shipUpgrades);
+  m_shipUpgrades = std::move(shipUpgrades);
 }
 
 void Player::applyShipUpgrades(Json const& upgrades) {
@@ -2133,7 +2133,7 @@ HumanoidIdentity const& Player::identity() const {
 }
 
 void Player::setIdentity(HumanoidIdentity identity) {
-  m_identity = move(identity);
+  m_identity = std::move(identity);
   updateIdentity();
 }
 
@@ -2258,7 +2258,7 @@ Json Player::diskStore() {
   for (auto& p : m_genericScriptContexts) {
     auto scriptStorage = p.second->getScriptStorage();
     if (!scriptStorage.empty())
-      genericScriptStorage[p.first] = move(scriptStorage);
+      genericScriptStorage[p.first] = std::move(scriptStorage);
   }
 
   return JsonObject{
@@ -2580,7 +2580,7 @@ Json Player::getSecretProperty(String const& name, Json defaultValue) const {
       { Logger::error("Exception reading secret player property '{}': {}", name, e.what()); }
   }
 
-  return move(defaultValue);
+  return defaultValue;
 }
 
 void Player::setSecretProperty(String const& name, Json const& value) {
diff --git a/source/game/StarPlayerInventory.cpp b/source/game/StarPlayerInventory.cpp
index 7c4ca3e..d7ba6a1 100644
--- a/source/game/StarPlayerInventory.cpp
+++ b/source/game/StarPlayerInventory.cpp
@@ -215,7 +215,7 @@ ItemPtr PlayerInventory::addItems(ItemPtr items) {
     m_equipment[EquipmentSlot::Back] = items->take(1);
 
   // Then, finally the bags
-  return addToBags(move(items));
+  return addToBags(std::move(items));
 }
 
 ItemPtr PlayerInventory::addToBags(ItemPtr items) {
@@ -776,9 +776,9 @@ void PlayerInventory::load(Json const& store) {
     auto newBag = ItemBag::loadStore(p.second);
     auto& bagPtr = m_bags[bagType];
     if (bagPtr)
-      *bagPtr = move(newBag);
+      *bagPtr = std::move(newBag);
     else
-      bagPtr = make_shared<ItemBag>(move(newBag));
+      bagPtr = make_shared<ItemBag>(std::move(newBag));
   }
 
   m_swapSlot = itemDatabase->diskLoad(store.get("swapSlot"));
@@ -838,7 +838,7 @@ Json PlayerInventory::store() const {
     {"trashSlot", itemDatabase->diskStore(m_trashSlot)},
     {"currencies", jsonFromMap(m_currencies)},
     {"customBarGroup", m_customBarGroup},
-    {"customBar", move(customBar)},
+    {"customBar", std::move(customBar)},
     {"selectedActionBar", jsonFromSelectedActionBarLocation(m_selectedActionBar)},
     {"beamAxe", itemDatabase->diskStore(m_essential.value(EssentialItem::BeamAxe))},
     {"wireTool", itemDatabase->diskStore(m_essential.value(EssentialItem::WireTool))},
@@ -848,7 +848,7 @@ Json PlayerInventory::store() const {
 }
 
 void PlayerInventory::forEveryItem(function<void(InventorySlot const&, ItemPtr&)> function) {
-  auto checkedFunction = [function = move(function)](InventorySlot const& slot, ItemPtr& item) {
+  auto checkedFunction = [function = std::move(function)](InventorySlot const& slot, ItemPtr& item) {
     if (item)
       function(slot, item);
   };
@@ -864,7 +864,7 @@ void PlayerInventory::forEveryItem(function<void(InventorySlot const&, ItemPtr&)
 }
 
 void PlayerInventory::forEveryItem(function<void(InventorySlot const&, ItemPtr const&)> function) const {
-  return const_cast<PlayerInventory*>(this)->forEveryItem([function = move(function)](InventorySlot const& slot, ItemPtr& item) {
+  return const_cast<PlayerInventory*>(this)->forEveryItem([function = std::move(function)](InventorySlot const& slot, ItemPtr& item) {
       function(slot, item);
     });
 }
diff --git a/source/game/StarPlayerStorage.cpp b/source/game/StarPlayerStorage.cpp
index 5bb3f4e..72932f1 100644
--- a/source/game/StarPlayerStorage.cpp
+++ b/source/game/StarPlayerStorage.cpp
@@ -269,9 +269,9 @@ void PlayerStorage::backupCycle(Uuid const& uuid) {
 }
 
 void PlayerStorage::setMetadata(String key, Json value) {
-  auto& val = m_metadata[move(key)];
+  auto& val = m_metadata[std::move(key)];
   if (val != value) {
-    val = move(value);
+    val = std::move(value);
     writeMetadata();
   }
 }
@@ -294,7 +294,7 @@ void PlayerStorage::writeMetadata() {
   for (auto const& p : m_savedPlayersCache)
     order.append(p.first.hex());
 
-  m_metadata["order"] = move(order);
+  m_metadata["order"] = std::move(order);
 
   String filename = File::relativeTo(m_storageDirectory, "metadata");
   File::overwriteFileWithRename(Json(m_metadata).printJson(0), filename);
diff --git a/source/game/StarPlayerUniverseMap.cpp b/source/game/StarPlayerUniverseMap.cpp
index 42167db..f8576a2 100644
--- a/source/game/StarPlayerUniverseMap.cpp
+++ b/source/game/StarPlayerUniverseMap.cpp
@@ -75,7 +75,7 @@ void PlayerUniverseMap::addOrbitBookmark(CelestialCoordinate const& system, Orbi
   if (system.isNull())
     throw StarException("Cannot add orbit bookmark to null system");
 
-  m_universeMaps[*m_serverUuid].systems[system.location()].bookmarks.add(move(bookmark));
+  m_universeMaps[*m_serverUuid].systems[system.location()].bookmarks.add(std::move(bookmark));
 }
 
 void PlayerUniverseMap::removeOrbitBookmark(CelestialCoordinate const& system, OrbitBookmark const& bookmark) {
@@ -90,7 +90,7 @@ List<TeleportBookmark> PlayerUniverseMap::teleportBookmarks() const {
 }
 
 void PlayerUniverseMap::addTeleportBookmark(TeleportBookmark bookmark) {
-  m_universeMaps[*m_serverUuid].teleportBookmarks.add(move(bookmark));
+  m_universeMaps[*m_serverUuid].teleportBookmarks.add(std::move(bookmark));
 }
 
 void PlayerUniverseMap::removeTeleportBookmark(TeleportBookmark const& bookmark) {
@@ -192,7 +192,7 @@ void PlayerUniverseMap::filterMappedObjects(CelestialCoordinate const& system, L
 }
 
 void PlayerUniverseMap::setServerUuid(Maybe<Uuid> serverUuid) {
-  m_serverUuid = move(serverUuid);
+  m_serverUuid = std::move(serverUuid);
   if (m_serverUuid && !m_universeMaps.contains(*m_serverUuid))
     m_universeMaps.set(*m_serverUuid, UniverseMap());
 }
diff --git a/source/game/StarProjectile.cpp b/source/game/StarProjectile.cpp
index 7355135..57d8ca8 100644
--- a/source/game/StarProjectile.cpp
+++ b/source/game/StarProjectile.cpp
@@ -142,7 +142,7 @@ pair<ByteArray, uint64_t> Projectile::writeNetState(uint64_t fromVersion) {
 }
 
 void Projectile::readNetState(ByteArray data, float interpolationTime) {
-  m_netGroup.readNetState(move(data), interpolationTime);
+  m_netGroup.readNetState(std::move(data), interpolationTime);
 }
 
 void Projectile::enableInterpolation(float extrapolationHint) {
@@ -371,7 +371,7 @@ void Projectile::render(RenderCallback* renderCallback) {
   }
   drawable.fullbright = m_config->fullbright;
   drawable.translate(position());
-  renderCallback->addDrawable(move(drawable), m_config->renderLayer);
+  renderCallback->addDrawable(std::move(drawable), m_config->renderLayer);
 }
 
 void Projectile::renderLightSources(RenderCallback* renderCallback) {
@@ -468,7 +468,7 @@ List<PhysicsForceRegion> Projectile::forceRegions() const {
     if (p.second.enabled.get()) {
       PhysicsForceRegion forceRegion = p.second.forceRegion;
       forceRegion.call([pos = position()](auto& fr) { fr.translate(pos); });
-      forces.append(move(forceRegion));
+      forces.append(std::move(forceRegion));
     }
   }
   return forces;
@@ -512,7 +512,7 @@ List<Particle> Projectile::sparkBlock(World* world, Vec2I const& position, Vec2F
       particle.finalVelocity = 0.5f * (particle.finalVelocity + Vec2F(Random::randf() - 0.5f, -20.0f + Random::randf()));
       particle.trail = true;
 
-      result.append(move(particle));
+      result.append(std::move(particle));
     }
   }
   return result;
@@ -733,7 +733,7 @@ void Projectile::processAction(Json const& action) {
       particle.finalVelocity = 0.5f * (particle.finalVelocity + Vec2F(Random::randf() - 0.5f, -20.0f + Random::randf()));
       particle.trail = true;
 
-      m_pendingRenderables.append(move(particle));
+      m_pendingRenderables.append(std::move(particle));
     }
 
   } else if (command == "particle") {
@@ -748,7 +748,7 @@ void Projectile::processAction(Json const& action) {
     }
     particle.translate(position());
     particle.velocity += m_referenceVelocity.value();
-    m_pendingRenderables.append(move(particle));
+    m_pendingRenderables.append(std::move(particle));
 
   } else if (command == "explosion") {
     if (isSlave())
@@ -796,7 +796,7 @@ void Projectile::processAction(Json const& action) {
       Particle particle(parameters.getObject("particle"));
       particle.translate(position());
       particle.velocity += m_referenceVelocity.value();
-      m_pendingRenderables.append(move(particle));
+      m_pendingRenderables.append(std::move(particle));
     }
 
   } else if (command == "item") {
@@ -816,7 +816,7 @@ void Projectile::processAction(Json const& action) {
 
     AudioInstancePtr sound = make_shared<AudioInstance>(*Root::singleton().assets()->audio(Random::randValueFrom(parameters.getArray("options")).toString()));
     sound->setPosition(position());
-    m_pendingRenderables.append(move(sound));
+    m_pendingRenderables.append(std::move(sound));
 
   } else if (command == "light") {
     if (!world()->isClient())
@@ -904,10 +904,10 @@ void Projectile::setup() {
     auto begin = processing.utf8().find_first_of('?');
     if (begin == NPos) {
       m_imageDirectives = "";
-      m_imageSuffix = move(processing);
+      m_imageSuffix = std::move(processing);
     }
     else if (begin == 0) {
-      m_imageDirectives = move(processing);
+      m_imageDirectives = std::move(processing);
       m_imageSuffix = "";
     }
     else {
diff --git a/source/game/StarQuests.cpp b/source/game/StarQuests.cpp
index d3c07c5..6643362 100644
--- a/source/game/StarQuests.cpp
+++ b/source/game/StarQuests.cpp
@@ -370,7 +370,7 @@ void Quest::setWorldId(Maybe<WorldId> worldId) {
 }
 
 void Quest::setLocation(Maybe<pair<Vec3I, SystemLocation>> location) {
-  m_location = move(location);
+  m_location = std::move(location);
 }
 
 void Quest::setServerUuid(Maybe<Uuid> serverUuid) {
diff --git a/source/game/StarRoot.cpp b/source/game/StarRoot.cpp
index 23abfd9..efb5e27 100644
--- a/source/game/StarRoot.cpp
+++ b/source/game/StarRoot.cpp
@@ -79,7 +79,7 @@ Root::Root(Settings settings) {
   if (!s_singleton.compare_exchange_strong(oldRoot, this))
     throw RootException("Singleton Root has been constructed twice");
 
-  m_settings = move(settings);
+  m_settings = std::move(settings);
   if (m_settings.runtimeConfigFile)
     m_runtimeConfigFile = toStoragePath(*m_settings.runtimeConfigFile);
 
@@ -299,7 +299,7 @@ void Root::reload() {
 
 void Root::reloadWithMods(StringList modDirectories) {
   MutexLocker locker(m_modsMutex);
-  m_modDirectories = move(modDirectories);
+  m_modDirectories = std::move(modDirectories);
   reload();
 }
 
@@ -363,7 +363,7 @@ void Root::fullyLoad() {
 }
 
 void Root::registerReloadListener(ListenerWeakPtr reloadListener) {
-  m_reloadListeners.addListener(move(reloadListener));
+  m_reloadListeners.addListener(std::move(reloadListener));
 }
 
 String Root::toStoragePath(String const& path) const {
@@ -630,10 +630,10 @@ StringList Root::scanForAssetSources(StringList const& directories) {
           }
         } else {
           namedSources[*assetSource->name] = assetSource;
-          assetSources.append(move(assetSource));
+          assetSources.append(std::move(assetSource));
         }
       } else {
-        assetSources.append(move(assetSource));
+        assetSources.append(std::move(assetSource));
       }
     }
   }
@@ -675,11 +675,11 @@ StringList Root::scanForAssetSources(StringList const& directories) {
 
     workingSet.remove(source);
 
-    dependencySortedSources.add(move(source));
+    dependencySortedSources.add(std::move(source));
   };
 
   for (auto source : assetSources)
-    dependencySortVisit(move(source));
+    dependencySortVisit(std::move(source));
 
   StringList sourcePaths;
   for (auto const& source : dependencySortedSources) {
diff --git a/source/game/StarRootLoader.cpp b/source/game/StarRootLoader.cpp
index 9ede365..f6843f3 100644
--- a/source/game/StarRootLoader.cpp
+++ b/source/game/StarRootLoader.cpp
@@ -106,7 +106,7 @@ RootLoader::RootLoader(Defaults defaults) {
   addSwitch("runtimeconfig",
       strf("Sets the path to the runtime configuration storage file relative to root directory, defauts to {}",
         defaults.runtimeConfigFile ? *defaults.runtimeConfigFile : "no storage file"));
-  m_defaults = move(defaults);
+  m_defaults = std::move(defaults);
 }
 
 pair<Root::Settings, RootLoader::Options> RootLoader::parseOrDie(
@@ -118,7 +118,7 @@ pair<Root::Settings, RootLoader::Options> RootLoader::parseOrDie(
 pair<RootUPtr, RootLoader::Options> RootLoader::initOrDie(StringList const& cmdLineArguments) const {
   auto p = parseOrDie(cmdLineArguments);
   auto root = make_unique<Root>(p.first);
-  return {move(root), p.second};
+  return {std::move(root), p.second};
 }
 
 pair<Root::Settings, RootLoader::Options> RootLoader::commandParseOrDie(int argc, char** argv) {
@@ -129,7 +129,7 @@ pair<Root::Settings, RootLoader::Options> RootLoader::commandParseOrDie(int argc
 pair<RootUPtr, RootLoader::Options> RootLoader::commandInitOrDie(int argc, char** argv) {
   auto p = commandParseOrDie(argc, argv);
   auto root = make_unique<Root>(p.first);
-  return {move(root), p.second};
+  return {std::move(root), p.second};
 }
 
 Root::Settings RootLoader::rootSettingsForOptions(Options const& options) const {
diff --git a/source/game/StarServerClientContext.cpp b/source/game/StarServerClientContext.cpp
index ff5b57a..838dae0 100644
--- a/source/game/StarServerClientContext.cpp
+++ b/source/game/StarServerClientContext.cpp
@@ -18,7 +18,7 @@ ServerClientContext::ServerClientContext(ConnectionId clientId, Maybe<HostAddres
     m_playerName(playerName),
     m_playerSpecies(playerSpecies),
     m_canBecomeAdmin(canBecomeAdmin),
-    m_shipChunks(move(initialShipChunks)) {
+    m_shipChunks(std::move(initialShipChunks)) {
   m_rpc.registerHandler("ship.applyShipUpgrades", [this](Json const& args) -> Json {
       RecursiveMutexLocker locker(m_mutex);
       setShipUpgrades(shipUpgrades().apply(args));
@@ -166,7 +166,7 @@ WorldChunks ServerClientContext::shipChunks() const {
 void ServerClientContext::updateShipChunks(WorldChunks newShipChunks) {
   RecursiveMutexLocker locker(m_mutex);
   m_shipChunksUpdate.merge(WorldStorage::getWorldChunksUpdate(m_shipChunks, newShipChunks), true);
-  m_shipChunks = move(newShipChunks);
+  m_shipChunks = std::move(newShipChunks);
 }
 
 void ServerClientContext::readUpdate(ByteArray data) {
@@ -202,7 +202,7 @@ void ServerClientContext::setSystemWorld(SystemWorldServerThreadPtr systemWorldT
   if (m_systemWorldThread == systemWorldThread)
     return;
 
-  m_systemWorldThread = move(systemWorldThread);
+  m_systemWorldThread = std::move(systemWorldThread);
 }
 
 SystemWorldServerThreadPtr ServerClientContext::systemWorld() const {
@@ -220,7 +220,7 @@ void ServerClientContext::setPlayerWorld(WorldServerThreadPtr worldThread) {
   if (m_worldThread == worldThread)
     return;
 
-  m_worldThread = move(worldThread);
+  m_worldThread = std::move(worldThread);
   if (m_worldThread)
     m_playerWorldIdNetState.set(m_worldThread->worldId());
   else
@@ -248,7 +248,7 @@ WarpToWorld ServerClientContext::playerReturnWarp() const {
 
 void ServerClientContext::setPlayerReturnWarp(WarpToWorld warp) {
   RecursiveMutexLocker locker(m_mutex);
-  m_returnWarp = move(warp);
+  m_returnWarp = std::move(warp);
 }
 
 WarpToWorld ServerClientContext::playerReviveWarp() const {
@@ -258,7 +258,7 @@ WarpToWorld ServerClientContext::playerReviveWarp() const {
 
 void ServerClientContext::setPlayerReviveWarp(WarpToWorld warp) {
   RecursiveMutexLocker locker(m_mutex);
-  m_reviveWarp = move(warp);
+  m_reviveWarp = std::move(warp);
 }
 
 void ServerClientContext::loadServerData(Json const& store) {
diff --git a/source/game/StarSky.cpp b/source/game/StarSky.cpp
index 05e6207..d9ac03a 100644
--- a/source/game/StarSky.cpp
+++ b/source/game/StarSky.cpp
@@ -71,7 +71,7 @@ pair<ByteArray, uint64_t> Sky::writeUpdate(uint64_t fromVersion) {
 }
 
 void Sky::readUpdate(ByteArray data) {
-  m_netGroup.readNetState(move(data));
+  m_netGroup.readNetState(std::move(data));
 }
 
 void Sky::stateUpdate() {
diff --git a/source/game/StarSpawnTypeDatabase.cpp b/source/game/StarSpawnTypeDatabase.cpp
index 2affb5a..7ae3281 100644
--- a/source/game/StarSpawnTypeDatabase.cpp
+++ b/source/game/StarSpawnTypeDatabase.cpp
@@ -83,7 +83,7 @@ SpawnProfile::SpawnProfile(Json const& config) {
 }
 
 SpawnProfile::SpawnProfile(StringSet spawnTypes, Json monsterParameters)
-  : spawnTypes(move(spawnTypes)), monsterParameters(move(monsterParameters)) {}
+  : spawnTypes(std::move(spawnTypes)), monsterParameters(std::move(monsterParameters)) {}
 
 Json SpawnProfile::toJson() const {
   return JsonObject{
diff --git a/source/game/StarSpawner.cpp b/source/game/StarSpawner.cpp
index f64ccfe..b313ba8 100644
--- a/source/game/StarSpawner.cpp
+++ b/source/game/StarSpawner.cpp
@@ -41,7 +41,7 @@ Spawner::Spawner() {
 }
 
 void Spawner::init(SpawnerFacadePtr facade) {
-  m_facade = move(facade);
+  m_facade = std::move(facade);
 }
 
 void Spawner::uninit() {
diff --git a/source/game/StarStagehand.cpp b/source/game/StarStagehand.cpp
index 06fa9ae..83b7673 100644
--- a/source/game/StarStagehand.cpp
+++ b/source/game/StarStagehand.cpp
@@ -82,7 +82,7 @@ pair<ByteArray, uint64_t> Stagehand::writeNetState(uint64_t fromVersion) {
 }
 
 void Stagehand::readNetState(ByteArray data, float) {
-  m_netGroup.readNetState(move(data));
+  m_netGroup.readNetState(std::move(data));
 }
 
 void Stagehand::update(float dt, uint64_t) {
diff --git a/source/game/StarStatCollection.cpp b/source/game/StarStatCollection.cpp
index 9f5e1f3..6ded538 100644
--- a/source/game/StarStatCollection.cpp
+++ b/source/game/StarStatCollection.cpp
@@ -166,7 +166,7 @@ void StatCollection::netElementsNeedLoad(bool) {
     StatModifierGroupMap allModifiers;
     for (auto const& p : m_statModifiersNetState)
       allModifiers.add(p.first, p.second);
-    m_stats.setAllStatModifierGroups(move(allModifiers));
+    m_stats.setAllStatModifierGroups(std::move(allModifiers));
   }
 
   for (auto const& pair : m_resourceValuesNetStates)
diff --git a/source/game/StarStatSet.cpp b/source/game/StarStatSet.cpp
index aa6513e..82258f8 100644
--- a/source/game/StarStatSet.cpp
+++ b/source/game/StarStatSet.cpp
@@ -4,7 +4,7 @@
 namespace Star {
 
 void StatSet::addStat(String statName, float baseValue) {
-  if (!m_baseStats.insert(move(statName), baseValue).second)
+  if (!m_baseStats.insert(std::move(statName), baseValue).second)
     throw StatusException::format("Added duplicate stat named '{}' in StatSet", statName);
   update(0.0f);
 }
@@ -42,7 +42,7 @@ void StatSet::setStatBaseValue(String const& statName, float value) {
 
 StatModifierGroupId StatSet::addStatModifierGroup(List<StatModifier> modifiers) {
   bool empty = modifiers.empty();
-  auto id = m_statModifierGroups.add(move(modifiers));
+  auto id = m_statModifierGroups.add(std::move(modifiers));
   if (!empty)
     update(0.0f);
   return id;
@@ -58,7 +58,7 @@ List<StatModifier> StatSet::statModifierGroup(StatModifierGroupId modifierGroupI
 
 void StatSet::addStatModifierGroup(StatModifierGroupId groupId, List<StatModifier> modifiers) {
   bool empty = modifiers.empty();
-  m_statModifierGroups.add(groupId, move(modifiers));
+  m_statModifierGroups.add(groupId, std::move(modifiers));
   if (!empty)
     update(0.0f);
 }
@@ -66,7 +66,7 @@ void StatSet::addStatModifierGroup(StatModifierGroupId groupId, List<StatModifie
 bool StatSet::setStatModifierGroup(StatModifierGroupId groupId, List<StatModifier> modifiers) {
   auto& list = m_statModifierGroups.get(groupId);
   if (list != modifiers) {
-    list = move(modifiers);
+    list = std::move(modifiers);
     update(0.0f);
     return true;
   }
@@ -95,7 +95,7 @@ StatModifierGroupMap const& StatSet::allStatModifierGroups() const {
 
 void StatSet::setAllStatModifierGroups(StatModifierGroupMap map) {
   if (m_statModifierGroups != map) {
-    m_statModifierGroups = move(map);
+    m_statModifierGroups = std::move(map);
     update(0.0f);
   }
 }
@@ -118,7 +118,7 @@ float StatSet::statEffectiveValue(String const& statName) const {
 }
 
 void StatSet::addResource(String resourceName, MVariant<String, float> max, MVariant<String, float> delta) {
-  auto pair = m_resources.insert({move(resourceName), Resource{move(max), move(delta), false, 0.0f, {}}});
+  auto pair = m_resources.insert({std::move(resourceName), Resource{std::move(max), std::move(delta), false, 0.0f, {}}});
   if (!pair.second)
     throw StatusException::format("Added duplicate resource named '{}' in StatSet", resourceName);
   update(0.0f);
diff --git a/source/game/StarStatistics.cpp b/source/game/StarStatistics.cpp
index 6582663..0c24619 100644
--- a/source/game/StarStatistics.cpp
+++ b/source/game/StarStatistics.cpp
@@ -8,7 +8,7 @@
 namespace Star {
 
 Statistics::Statistics(String const& storageDirectory, StatisticsServicePtr service) {
-  m_service = move(service);
+  m_service = std::move(service);
   m_initialized = !m_service;
   m_storageDirectory = storageDirectory;
   readStatistics();
diff --git a/source/game/StarStatusController.cpp b/source/game/StarStatusController.cpp
index ba0930c..fcf9924 100644
--- a/source/game/StarStatusController.cpp
+++ b/source/game/StarStatusController.cpp
@@ -75,10 +75,10 @@ Json StatusController::diskStore() const {
 
   return JsonObject{
       {"statusProperties", m_statusProperties.get()},
-      {"persistentEffectCategories", move(persistentEffectCategories)},
-      {"ephemeralEffects", move(ephemeralEffects)},
-      {"resourceValues", move(resourceValues)},
-      {"resourcesLocked", move(resourcesLocked)},
+      {"persistentEffectCategories", std::move(persistentEffectCategories)},
+      {"ephemeralEffects", std::move(ephemeralEffects)},
+      {"resourceValues", std::move(resourceValues)},
+      {"resourcesLocked", std::move(resourcesLocked)},
   };
 }
 
@@ -111,7 +111,7 @@ Json StatusController::statusProperty(String const& name, Json const& def) const
 void StatusController::setStatusProperty(String const& name, Json value) {
   m_statusProperties.update([&](JsonObject& statusProperties) {
     if (statusProperties[name] != value) {
-      statusProperties[name] = move(value);
+      statusProperties[name] = std::move(value);
       return true;
     }
     return false;
@@ -355,11 +355,11 @@ List<DamageNotification> StatusController::applyDamageRequest(DamageRequest cons
 }
 
 void StatusController::hitOther(EntityId targetEntityId, DamageRequest damageRequest) {
-  m_recentHitsGiven.add({targetEntityId, move(damageRequest)});
+  m_recentHitsGiven.add({targetEntityId, std::move(damageRequest)});
 }
 
 void StatusController::damagedOther(DamageNotification damageNotification) {
-  m_recentDamageGiven.add(move(damageNotification));
+  m_recentDamageGiven.add(std::move(damageNotification));
 }
 
 List<DamageNotification> StatusController::pullSelfDamageNotifications() {
@@ -367,10 +367,10 @@ List<DamageNotification> StatusController::pullSelfDamageNotifications() {
 }
 
 void StatusController::applySelfDamageRequest(DamageRequest dr) {
-  auto damageNotifications = applyDamageRequest(move(dr));
+  auto damageNotifications = applyDamageRequest(std::move(dr));
   for (auto const& dn : damageNotifications)
     m_recentDamageTaken.add(dn);
-  m_pendingSelfDamageNotifications.appendAll(move(damageNotifications));
+  m_pendingSelfDamageNotifications.appendAll(std::move(damageNotifications));
 }
 
 pair<List<DamageNotification>, uint64_t> StatusController::damageTakenSince(uint64_t since) const {
@@ -514,7 +514,7 @@ void StatusController::tickMaster(float dt) {
   for (auto const& pair : m_uniqueEffects)
     parentDirectives.append(pair.second.parentDirectives);
 
-  m_parentDirectives.set(move(parentDirectives));
+  m_parentDirectives.set(std::move(parentDirectives));
 
   updateAnimators(dt);
 }
@@ -570,7 +570,7 @@ Maybe<Json> StatusController::receiveMessage(String const& message, bool localMe
 }
 
 StatusController::EffectAnimator::EffectAnimator(Maybe<String> config) {
-  animationConfig = move(config);
+  animationConfig = std::move(config);
   animator = animationConfig ? NetworkedAnimator(*animationConfig) : NetworkedAnimator();
 }
 
@@ -623,8 +623,8 @@ StatusController::UniqueEffectMetadata::UniqueEffectMetadata() {
 
 StatusController::UniqueEffectMetadata::UniqueEffectMetadata(UniqueStatusEffect effect, Maybe<float> duration, Maybe<EntityId> sourceEntityId)
   : UniqueEffectMetadata() {
-  this->effect = move(effect);
-  this->duration = move(duration);
+  this->effect = std::move(effect);
+  this->duration = std::move(duration);
   this->maxDuration.set(this->duration.value());
   this->sourceEntityId.set(sourceEntityId);
 }
diff --git a/source/game/StarStoredFunctions.cpp b/source/game/StarStoredFunctions.cpp
index 0db0356..7905f66 100644
--- a/source/game/StarStoredFunctions.cpp
+++ b/source/game/StarStoredFunctions.cpp
@@ -10,7 +10,7 @@ StoredFunction::StoredFunction(ParametricFunction<double, double> data) {
   if (data.empty())
     throw StoredFunctionException("StoredFunction constructor called on function with no data points");
 
-  m_function = move(data);
+  m_function = std::move(data);
 
   // Determine whether the function is monotonically increasing, monotonically
   // decreasing, totally flat (technically both monotonically increasing and
@@ -104,14 +104,14 @@ StoredFunction::SearchResult StoredFunction::search(double targetValue, double v
   return result;
 }
 
-StoredFunction2::StoredFunction2(MultiTable2D table) : table(move(table)) {}
+StoredFunction2::StoredFunction2(MultiTable2D table) : table(std::move(table)) {}
 
 double StoredFunction2::evaluate(double x, double y) const {
   return table.interpolate({x, y});
 }
 
 StoredConfigFunction::StoredConfigFunction(ParametricTable<int, Json> data) {
-  m_data = move(data);
+  m_data = std::move(data);
 }
 
 Json StoredConfigFunction::get(double value) const {
diff --git a/source/game/StarSystemWorld.cpp b/source/game/StarSystemWorld.cpp
index 3708e46..c7e1213 100644
--- a/source/game/StarSystemWorld.cpp
+++ b/source/game/StarSystemWorld.cpp
@@ -116,7 +116,7 @@ SystemWorldConfig SystemWorldConfig::fromJson(Json const& json) {
 }
 
 SystemWorld::SystemWorld(ClockConstPtr universeClock, CelestialDatabasePtr celestialDatabase)
-  : m_celestialDatabase(move(celestialDatabase)), m_universeClock(move(universeClock)) {
+  : m_celestialDatabase(std::move(celestialDatabase)), m_universeClock(std::move(universeClock)) {
   m_config = SystemWorldConfig::fromJson(Root::singleton().assets()->json("/systemworld.config"));
 }
 
@@ -317,13 +317,13 @@ Maybe<WarpAction> SystemWorld::objectWarpAction(Uuid const& uuid) const {
 }
 
 SystemObject::SystemObject(SystemObjectConfig config, Uuid uuid, Vec2F const& position, JsonObject parameters)
-  : m_config(move(config)), m_uuid(move(uuid)), m_spawnTime(0.0f), m_parameters(move(parameters)) {
+  : m_config(std::move(config)), m_uuid(std::move(uuid)), m_spawnTime(0.0f), m_parameters(std::move(parameters)) {
   setPosition(position);
   init();
 }
 
 SystemObject::SystemObject(SystemObjectConfig config, Uuid uuid, Vec2F const& position, double spawnTime, JsonObject parameters)
-  : m_config(move(config)), m_uuid(move(uuid)), m_spawnTime(move(spawnTime)), m_parameters(move(parameters)) {
+  : m_config(std::move(config)), m_uuid(std::move(uuid)), m_spawnTime(std::move(spawnTime)), m_parameters(std::move(parameters)) {
   setPosition(position);
   for (auto p : m_config.generatedParameters) {
     if (!m_parameters.contains(p.first))
@@ -458,7 +458,7 @@ pair<ByteArray, uint64_t> SystemObject::writeNetState(uint64_t fromVersion) {
 }
 
 void SystemObject::readNetState(ByteArray data, float interpolationTime) {
-  m_netGroup.readNetState(move(data), interpolationTime);
+  m_netGroup.readNetState(std::move(data), interpolationTime);
 }
 
 ByteArray SystemObject::netStore() const {
@@ -489,7 +489,7 @@ void SystemObject::setPosition(Vec2F const& position) {
 }
 
 SystemClientShip::SystemClientShip(SystemWorld* system, Uuid uuid, float speed, SystemLocation const& location)
-  : m_uuid(move(uuid)) {
+  : m_uuid(std::move(uuid)) {
   m_systemLocation.set(location);
   setPosition(system->systemLocationPosition(location).value({}));
 
@@ -620,7 +620,7 @@ pair<ByteArray, uint64_t> SystemClientShip::writeNetState(uint64_t fromVersion)
 }
 
 void SystemClientShip::readNetState(ByteArray data, float interpolationTime) {
-  m_netGroup.readNetState(move(data), interpolationTime);
+  m_netGroup.readNetState(std::move(data), interpolationTime);
 }
 
 ByteArray SystemClientShip::netStore() const {
diff --git a/source/game/StarSystemWorld.hpp b/source/game/StarSystemWorld.hpp
index c68bc59..ab0b63a 100644
--- a/source/game/StarSystemWorld.hpp
+++ b/source/game/StarSystemWorld.hpp
@@ -76,6 +76,8 @@ class SystemWorld {
 public:
   SystemWorld(ClockConstPtr universeClock, CelestialDatabasePtr celestialDatabase);
 
+  virtual ~SystemWorld() = default;
+
   SystemWorldConfig const& systemConfig() const;
   double time() const;
   Vec3I location() const;
diff --git a/source/game/StarSystemWorldClient.cpp b/source/game/StarSystemWorldClient.cpp
index da28c98..eb25124 100644
--- a/source/game/StarSystemWorldClient.cpp
+++ b/source/game/StarSystemWorldClient.cpp
@@ -7,7 +7,7 @@
 namespace Star {
 
 SystemWorldClient::SystemWorldClient(ClockConstPtr universeClock, CelestialDatabasePtr celestialDatabase, PlayerUniverseMapPtr universeMap)
-  : SystemWorld(universeClock, celestialDatabase), m_universeMap(move(universeMap)) {}
+  : SystemWorld(universeClock, celestialDatabase), m_universeMap(std::move(universeMap)) {}
 
 CelestialCoordinate SystemWorldClient::currentSystem() const {
   return CelestialCoordinate(m_location);
@@ -102,7 +102,7 @@ SystemClientShipPtr SystemWorldClient::getShip(Uuid const & uuid) const
 
 Uuid SystemWorldClient::spawnObject(String typeName, Maybe<Vec2F> position, Maybe<Uuid> const& uuid, JsonObject overrides) {
   Uuid objectUuid = uuid.value(Uuid());
-  m_outgoingPackets.append(make_shared<SystemObjectSpawnPacket>(move(typeName), objectUuid, move(position), move(overrides)));
+  m_outgoingPackets.append(make_shared<SystemObjectSpawnPacket>(std::move(typeName), objectUuid, std::move(position), std::move(overrides)));
   return objectUuid;
 }
 
@@ -165,7 +165,7 @@ List<PacketPtr> SystemWorldClient::pullOutgoingPackets() {
 }
 
 SystemObjectPtr SystemWorldClient::netLoadObject(ByteArray netStore) {
-  DataStreamBuffer ds(move(netStore));
+  DataStreamBuffer ds(std::move(netStore));
   Uuid uuid = ds.read<Uuid>();
 
   String name = ds.read<String>();
@@ -179,7 +179,7 @@ SystemObjectPtr SystemWorldClient::netLoadObject(ByteArray netStore) {
 
 SystemClientShipPtr SystemWorldClient::netLoadShip(ByteArray netStore)
 {
-  DataStreamBuffer ds(move(netStore));
+  DataStreamBuffer ds(std::move(netStore));
   Uuid uuid = ds.read<Uuid>();
   SystemLocation location = ds.read<SystemLocation>();
   return make_shared<SystemClientShip>(this, uuid, location);
diff --git a/source/game/StarSystemWorldServer.cpp b/source/game/StarSystemWorldServer.cpp
index 39a1aad..3b847eb 100644
--- a/source/game/StarSystemWorldServer.cpp
+++ b/source/game/StarSystemWorldServer.cpp
@@ -10,8 +10,8 @@
 namespace Star {
 
 SystemWorldServer::SystemWorldServer(Vec3I location, ClockConstPtr universeClock, CelestialDatabasePtr celestialDatabase)
-  : SystemWorld(move(universeClock), move(celestialDatabase)) {
-  m_location = move(location);
+  : SystemWorld(std::move(universeClock), std::move(celestialDatabase)) {
+  m_location = std::move(location);
 
   placeInitialObjects();
 
@@ -21,7 +21,7 @@ SystemWorldServer::SystemWorldServer(Vec3I location, ClockConstPtr universeClock
 }
 
 SystemWorldServer::SystemWorldServer(Json const& diskStore, ClockConstPtr universeClock, CelestialDatabasePtr celestialDatabase)
-  : SystemWorld(move(universeClock), move(celestialDatabase)) {
+  : SystemWorld(std::move(universeClock), std::move(celestialDatabase)) {
   m_location = jsonToVec3I(diskStore.get("location"));
 
   for (auto objectStore : diskStore.getArray("objects")) {
diff --git a/source/game/StarSystemWorldServerThread.cpp b/source/game/StarSystemWorldServerThread.cpp
index 55488e0..3ec26a7 100644
--- a/source/game/StarSystemWorldServerThread.cpp
+++ b/source/game/StarSystemWorldServerThread.cpp
@@ -47,7 +47,7 @@ void SystemWorldServerThread::removeClient(ConnectionId clientId) {
 }
 
 void SystemWorldServerThread::setPause(shared_ptr<const atomic<bool>> pause) {
-  m_pause = move(pause);
+  m_pause = std::move(pause);
 }
 
 void SystemWorldServerThread::run() {
@@ -127,7 +127,7 @@ void SystemWorldServerThread::setClientDestination(ConnectionId clientId, System
 
 void SystemWorldServerThread::executeClientShipAction(ConnectionId clientId, ClientShipAction action) {
   WriteLocker locker(m_queueMutex);
-  m_clientShipActions.append({clientId, move(action)});
+  m_clientShipActions.append({clientId, std::move(action)});
 }
 
 SystemLocation SystemWorldServerThread::clientShipLocation(ConnectionId clientId) {
@@ -160,7 +160,7 @@ void SystemWorldServerThread::setUpdateAction(function<void(SystemWorldServerThr
 
 void SystemWorldServerThread::pushIncomingPacket(ConnectionId clientId, PacketPtr packet) {
   WriteLocker locker(m_queueMutex);
-  m_incomingPacketQueue.append({move(clientId), move(packet)});
+  m_incomingPacketQueue.append({std::move(clientId), std::move(packet)});
 }
 
 List<PacketPtr> SystemWorldServerThread::pullOutgoingPackets(ConnectionId clientId) {
diff --git a/source/game/StarTeamClient.cpp b/source/game/StarTeamClient.cpp
index c1e2751..8bc6cfd 100644
--- a/source/game/StarTeamClient.cpp
+++ b/source/game/StarTeamClient.cpp
@@ -192,7 +192,7 @@ void TeamClient::forceUpdate() {
 
 void TeamClient::invokeRemote(String const& method, Json const& args, function<void(Json const&)> responseFunction) {
   auto promise = m_clientContext->rpcInterface()->invokeRemote(method, args);
-  m_pendingResponses.append({move(promise), move(responseFunction)});
+  m_pendingResponses.append({std::move(promise), std::move(responseFunction)});
 }
 
 void TeamClient::handleRpcResponses() {
@@ -205,7 +205,7 @@ void TeamClient::handleRpcResponses() {
           handler.second(*res);
       }
     } else {
-      stillPendingResponses.append(move(handler));
+      stillPendingResponses.append(std::move(handler));
     }
   }
   m_pendingResponses = stillPendingResponses;
diff --git a/source/game/StarTeamManager.cpp b/source/game/StarTeamManager.cpp
index d741963..d7c6c3d 100644
--- a/source/game/StarTeamManager.cpp
+++ b/source/game/StarTeamManager.cpp
@@ -24,7 +24,7 @@ JsonRpcHandlers TeamManager::rpcHandlers() {
 }
 
 void TeamManager::setConnectedPlayers(StringMap<List<Uuid>> const& connectedPlayers) {
-  m_connectedPlayers = move(connectedPlayers);
+  m_connectedPlayers = std::move(connectedPlayers);
 }
 
 void TeamManager::playerDisconnected(Uuid const& playerUuid) {
diff --git a/source/game/StarTechController.cpp b/source/game/StarTechController.cpp
index f99a718..4ead428 100644
--- a/source/game/StarTechController.cpp
+++ b/source/game/StarTechController.cpp
@@ -277,7 +277,7 @@ List<Drawable> TechController::backDrawables() {
     if (animator->isVisible()) {
       for (auto& piece : animator->animator.drawablesWithZLevel(m_movementController->position())) {
         if (piece.second < 0.0f)
-          drawables.append(move(piece.first));
+          drawables.append(std::move(piece.first));
       }
     }
   }
@@ -292,7 +292,7 @@ List<Drawable> TechController::frontDrawables() {
     if (animator->isVisible()) {
       for (auto& piece : animator->animator.drawablesWithZLevel(m_movementController->position())) {
         if (piece.second >= 0.0f)
-          drawables.append(move(piece.first));
+          drawables.append(std::move(piece.first));
       }
     }
   }
@@ -346,7 +346,7 @@ Maybe<Json> TechController::receiveMessage(String const& message, bool localMess
 }
 
 TechController::TechAnimator::TechAnimator(Maybe<String> ac) {
-  animationConfig = move(ac);
+  animationConfig = std::move(ac);
   animator = animationConfig ? NetworkedAnimator(*animationConfig) : NetworkedAnimator();
   netGroup.addNetElement(&animator);
   netGroup.addNetElement(&visible);
@@ -511,7 +511,7 @@ LuaCallbacks TechController::makeTechCallbacks(TechModule& techModule) {
       DirectivesGroup newParentDirectives;
       for (auto& module : m_techModules)
         newParentDirectives.append(module.parentDirectives);
-      m_parentDirectives.set(move(newParentDirectives));
+      m_parentDirectives.set(std::move(newParentDirectives));
     });
 
   callbacks.registerCallback("setParentHidden", [this](bool hidden) {
diff --git a/source/game/StarTerrainDatabase.cpp b/source/game/StarTerrainDatabase.cpp
index a2b33fd..1a6bbb2 100644
--- a/source/game/StarTerrainDatabase.cpp
+++ b/source/game/StarTerrainDatabase.cpp
@@ -50,7 +50,7 @@ TerrainSelectorParameters TerrainSelectorParameters::withCommonality(float commo
 }
 
 TerrainSelector::TerrainSelector(String type, Json config, TerrainSelectorParameters parameters)
-  : type(move(type)), config(move(config)), parameters(move(parameters)) {}
+  : type(std::move(type)), config(std::move(config)), parameters(std::move(parameters)) {}
 
 TerrainSelector::~TerrainSelector() {}
 
diff --git a/source/game/StarTileSectorArray.hpp b/source/game/StarTileSectorArray.hpp
index 40378db..fb96229 100644
--- a/source/game/StarTileSectorArray.hpp
+++ b/source/game/StarTileSectorArray.hpp
@@ -146,7 +146,7 @@ TileSectorArray<Tile, SectorSize>::TileSectorArray() {}
 
 template <typename Tile, unsigned SectorSize>
 TileSectorArray<Tile, SectorSize>::TileSectorArray(Vec2U const& size, Tile defaultTile) {
-  init(size, move(defaultTile));
+  init(size, std::move(defaultTile));
 }
 
 template <typename Tile, unsigned SectorSize>
@@ -154,7 +154,7 @@ void TileSectorArray<Tile, SectorSize>::init(Vec2U const& size, Tile defaultTile
   m_worldSize = size;
   // Initialize to enough sectors to fit world size at least.
   m_tileSectors.init((size[0] + SectorSize - 1) / SectorSize, (size[1] + SectorSize - 1) / SectorSize);
-  m_default = move(defaultTile);
+  m_default = std::move(defaultTile);
 }
 
 template <typename Tile, unsigned SectorSize>
@@ -210,13 +210,13 @@ auto TileSectorArray<Tile, SectorSize>::adjacentSector(Sector const& sector, Vec
 template <typename Tile, unsigned SectorSize>
 void TileSectorArray<Tile, SectorSize>::loadSector(Sector const& sector, ArrayPtr tile) {
   if (sectorValid(sector))
-    m_tileSectors.loadSector(sector, move(tile));
+    m_tileSectors.loadSector(sector, std::move(tile));
 }
 
 template <typename Tile, unsigned SectorSize>
 void TileSectorArray<Tile, SectorSize>::loadDefaultSector(Sector const& sector) {
   if (sectorValid(sector))
-    m_tileSectors.loadSector(sector, make_unique<Array>(m_default));
+    m_tileSectors.loadSector(sector, std::make_unique<Array>(m_default));
 }
 
 template <typename Tile, unsigned SectorSize>
diff --git a/source/game/StarToolUser.cpp b/source/game/StarToolUser.cpp
index dd6f5ff..c9bd068 100644
--- a/source/game/StarToolUser.cpp
+++ b/source/game/StarToolUser.cpp
@@ -285,18 +285,18 @@ void ToolUser::setupHumanoidHandItemDrawables(Humanoid& humanoid) const {
     auto setRotated = [&](String const& backFrameOverride, String const& frontFrameOverride, List<Drawable> drawables, bool twoHanded) {
       if (primary || twoHanded) {
         humanoid.setPrimaryHandFrameOverrides(backFrameOverride, frontFrameOverride);
-        humanoid.setPrimaryHandDrawables(move(drawables));
+        humanoid.setPrimaryHandDrawables(std::move(drawables));
       } else {
         humanoid.setAltHandFrameOverrides(backFrameOverride, frontFrameOverride);
-        humanoid.setAltHandDrawables(move(drawables));
+        humanoid.setAltHandDrawables(std::move(drawables));
       }
     };
 
     auto setNonRotated = [&](List<Drawable> drawables) {
       if (primary)
-        humanoid.setPrimaryHandNonRotatedDrawables(move(drawables));
+        humanoid.setPrimaryHandNonRotatedDrawables(std::move(drawables));
       else
-        humanoid.setAltHandNonRotatedDrawables(move(drawables));
+        humanoid.setAltHandNonRotatedDrawables(std::move(drawables));
     };
 
     ItemPtr handItem = primary ? m_primaryHandItem.get() : m_altHandItem.get();
@@ -584,8 +584,8 @@ void ToolUser::setItems(ItemPtr newPrimaryHandItem, ItemPtr newAltHandItem) {
   if (m_altHandItem.get() != newAltHandItem)
     m_fireAlt = false;
 
-  m_primaryHandItem.set(move(newPrimaryHandItem));
-  m_altHandItem.set(move(newAltHandItem));
+  m_primaryHandItem.set(std::move(newPrimaryHandItem));
+  m_altHandItem.set(std::move(newAltHandItem));
 
   initPrimaryHandItem();
   initAltHandItem();
@@ -737,7 +737,7 @@ ItemPtr const& ToolUser::NetItem::get() const {
 
 void ToolUser::NetItem::set(ItemPtr item) {
   if (m_item != item) {
-    m_item = move(item);
+    m_item = std::move(item);
     m_newItem = true;
     if (auto netItem = as<NetElement>(m_item.get())) {
       netItem->initNetVersion(m_netVersion);
diff --git a/source/game/StarTreasure.cpp b/source/game/StarTreasure.cpp
index 2efca99..7493d62 100644
--- a/source/game/StarTreasure.cpp
+++ b/source/game/StarTreasure.cpp
@@ -65,7 +65,7 @@ TreasureDatabase::TreasureDatabase() {
         itemPool.levelVariance = jsonToVec2F(config.get("levelVariance", JsonArray{0, 0}));
         itemPool.allowDuplication = config.getBool("allowDuplication", true);
 
-        treasurePool.addPoint(startLevel, move(itemPool));
+        treasurePool.addPoint(startLevel, std::move(itemPool));
       }
     }
   }
diff --git a/source/game/StarUniverseClient.cpp b/source/game/StarUniverseClient.cpp
index f355965..6f089d4 100644
--- a/source/game/StarUniverseClient.cpp
+++ b/source/game/StarUniverseClient.cpp
@@ -29,8 +29,8 @@ namespace Star {
 
 UniverseClient::UniverseClient(PlayerStoragePtr playerStorage, StatisticsPtr statistics) {
   m_storageTriggerDeadline = 0;
-  m_playerStorage = move(playerStorage);
-  m_statistics = move(statistics);
+  m_playerStorage = std::move(playerStorage);
+  m_statistics = std::move(statistics);
   m_pause = false;
   m_luaRoot = make_shared<LuaRoot>();
   reset();
@@ -127,8 +127,8 @@ Maybe<String> UniverseClient::connect(UniverseConnection connection, bool allowA
     for (auto& pair : m_luaCallbacks)
       m_worldClient->setLuaCallbacks(pair.first, pair.second);
 
-    m_connection = move(connection);
-    m_celestialDatabase = make_shared<CelestialSlaveDatabase>(move(success->celestialInformation));
+    m_connection = std::move(connection);
+    m_celestialDatabase = make_shared<CelestialSlaveDatabase>(std::move(success->celestialInformation));
     m_systemWorldClient = make_shared<SystemWorldClient>(m_universeClock, m_celestialDatabase, m_mainPlayer->universeMap());
 
     Logger::info("UniverseClient: Joined {} server as client {}", m_legacyServer ? "Starbound" : "OpenStarbound", success->clientId);
@@ -246,11 +246,11 @@ void UniverseClient::update(float dt) {
 
   auto contextUpdate = m_clientContext->writeUpdate();
   if (!contextUpdate.empty())
-    m_connection->pushSingle(make_shared<ClientContextUpdatePacket>(move(contextUpdate)));
+    m_connection->pushSingle(make_shared<ClientContextUpdatePacket>(std::move(contextUpdate)));
 
   auto celestialRequests = m_celestialDatabase->pullRequests();
   if (!celestialRequests.empty())
-    m_connection->pushSingle(make_shared<CelestialRequestPacket>(move(celestialRequests)));
+    m_connection->pushSingle(make_shared<CelestialRequestPacket>(std::move(celestialRequests)));
 
   m_connection->send();
 
@@ -276,7 +276,7 @@ void UniverseClient::update(float dt) {
             {"species", m_mainPlayer->species()},
             {"mode", PlayerModeNames.getRight(m_mainPlayer->modeType())}
           });
-        m_mainPlayer->setPendingCinematic(Json(move(cinematic)));
+        m_mainPlayer->setPendingCinematic(Json(std::move(cinematic)));
         if (!m_worldClient->respawnInWorld())
           m_pendingWarp = WarpAlias::OwnShip;
         m_warpDelay.reset();
@@ -651,7 +651,7 @@ void UniverseClient::handlePackets(List<PacketPtr> const& packets) {
       break; // Stop handling other packets
 
     } else if (auto celestialResponse = as<CelestialResponsePacket>(packet)) {
-      m_celestialDatabase->pushResponses(move(celestialResponse->responses));
+      m_celestialDatabase->pushResponses(std::move(celestialResponse->responses));
 
     } else if (auto warpResult = as<PlayerWarpResultPacket>(packet)) {
       if (m_mainPlayer->isDeploying() && m_warping && m_warping->is<WarpToPlayer>()) {
diff --git a/source/game/StarUniverseConnection.cpp b/source/game/StarUniverseConnection.cpp
index f3c2b28..18b6da9 100644
--- a/source/game/StarUniverseConnection.cpp
+++ b/source/game/StarUniverseConnection.cpp
@@ -6,10 +6,10 @@ namespace Star {
 static const int PacketSocketPollSleep = 1;
 
 UniverseConnection::UniverseConnection(PacketSocketUPtr packetSocket)
-  : m_packetSocket(move(packetSocket)) {}
+  : m_packetSocket(std::move(packetSocket)) {}
 
 UniverseConnection::UniverseConnection(UniverseConnection&& rhs) {
-  operator=(move(rhs));
+  operator=(std::move(rhs));
 }
 
 UniverseConnection::~UniverseConnection() {
@@ -37,12 +37,12 @@ void UniverseConnection::close() {
 
 void UniverseConnection::push(List<PacketPtr> packets) {
   MutexLocker locker(m_mutex);
-  m_sendQueue.appendAll(move(packets));
+  m_sendQueue.appendAll(std::move(packets));
 }
 
 void UniverseConnection::pushSingle(PacketPtr packet) {
   MutexLocker locker(m_mutex);
-  m_sendQueue.append(move(packet));
+  m_sendQueue.append(std::move(packet));
 }
 
 List<PacketPtr> UniverseConnection::pull() {
@@ -122,7 +122,7 @@ Maybe<PacketStats> UniverseConnection::outgoingStats() const {
 }
 
 UniverseConnectionServer::UniverseConnectionServer(PacketReceiveCallback packetReceiver)
-  : m_packetReceiver(move(packetReceiver)), m_shutdown(false) {
+  : m_packetReceiver(std::move(packetReceiver)), m_shutdown(false) {
   m_processingLoop = Thread::invoke("UniverseConnectionServer::processingLoop", [this]() {
       RecursiveMutexLocker connectionsLocker(m_connectionsMutex);
       try {
@@ -152,7 +152,7 @@ UniverseConnectionServer::UniverseConnectionServer(PacketReceiveCallback packetR
               connectionLocker.unlock();
 
               try {
-                m_packetReceiver(this, p.first, move(toReceive));
+                m_packetReceiver(this, p.first, std::move(toReceive));
               } catch (std::exception const& e) {
                 Logger::error("Exception caught handling incoming server packets, disconnecting client '{}' {}", p.first, outputException(e, true));
 
@@ -215,11 +215,11 @@ void UniverseConnectionServer::addConnection(ConnectionId clientId, UniverseConn
     throw UniverseConnectionException::format("Client '{}' already exists in UniverseConnectionServer::addConnection", clientId);
 
   auto connection = make_shared<Connection>();
-  connection->packetSocket = move(uc.m_packetSocket);
-  connection->sendQueue = move(uc.m_sendQueue);
-  connection->receiveQueue = move(uc.m_receiveQueue);
+  connection->packetSocket = std::move(uc.m_packetSocket);
+  connection->sendQueue = std::move(uc.m_sendQueue);
+  connection->receiveQueue = std::move(uc.m_receiveQueue);
   connection->lastActivityTime = Time::monotonicMilliseconds();
-  m_connections.add(clientId, move(connection));
+  m_connections.add(clientId, std::move(connection));
 }
 
 UniverseConnection UniverseConnectionServer::removeConnection(ConnectionId clientId) {
@@ -232,8 +232,8 @@ UniverseConnection UniverseConnectionServer::removeConnection(ConnectionId clien
 
   UniverseConnection uc;
   uc.m_packetSocket = take(conn->packetSocket);
-  uc.m_sendQueue = move(conn->sendQueue);
-  uc.m_receiveQueue = move(conn->receiveQueue);
+  uc.m_sendQueue = std::move(conn->sendQueue);
+  uc.m_receiveQueue = std::move(conn->receiveQueue);
   return uc;
 }
 
@@ -249,7 +249,7 @@ void UniverseConnectionServer::sendPackets(ConnectionId clientId, List<PacketPtr
   RecursiveMutexLocker connectionsLocker(m_connectionsMutex);
   if (auto conn = m_connections.value(clientId)) {
     MutexLocker connectionLocker(conn->mutex);
-    conn->sendQueue.appendAll(move(packets));
+    conn->sendQueue.appendAll(std::move(packets));
 
     if (conn->packetSocket->isOpen()) {
       conn->packetSocket->sendPackets(take(conn->sendQueue));
diff --git a/source/game/StarUniverseServer.cpp b/source/game/StarUniverseServer.cpp
index 3b04358..783bde2 100644
--- a/source/game/StarUniverseServer.cpp
+++ b/source/game/StarUniverseServer.cpp
@@ -112,15 +112,15 @@ void UniverseServer::addClient(UniverseConnection remoteConnection) {
   RecursiveMutexLocker locker(m_mainLock);
   // Binding requires us to make the given lambda copy constructible, so the
   // make_shared is requried here.
-  m_connectionAcceptThreads.append(Thread::invoke("UniverseServer::acceptConnection", [this, conn = make_shared<UniverseConnection>(move(remoteConnection))]() {
-      acceptConnection(move(*conn), {});
+  m_connectionAcceptThreads.append(Thread::invoke("UniverseServer::acceptConnection", [this, conn = make_shared<UniverseConnection>(std::move(remoteConnection))]() {
+      acceptConnection(std::move(*conn), {});
     }));
 }
 
 UniverseConnection UniverseServer::addLocalClient() {
   auto pair = LocalPacketSocket::openPair();
-  addClient(UniverseConnection(move(pair.first)));
-  return UniverseConnection(move(pair.second));
+  addClient(UniverseConnection(std::move(pair.first)));
+  return UniverseConnection(std::move(pair.second));
 }
 
 void UniverseServer::stop() {
@@ -274,7 +274,7 @@ RpcThreadPromise<Json> UniverseServer::sendWorldMessage(WorldId const& worldId,
 
 void UniverseServer::clientWarpPlayer(ConnectionId clientId, WarpAction action, bool deploy) {
   RecursiveMutexLocker locker(m_mainLock);
-  m_pendingPlayerWarps[clientId] = pair<WarpAction, bool>(move(action), move(deploy));
+  m_pendingPlayerWarps[clientId] = pair<WarpAction, bool>(std::move(action), std::move(deploy));
 }
 
 void UniverseServer::clientFlyShip(ConnectionId clientId, Vec3I const& system, SystemLocation const& location) {
@@ -402,7 +402,7 @@ bool UniverseServer::unbanIp(String const& addressString) {
   if (addressLookup.isLeft()) {
     return false;
   } else {
-    HostAddress address = move(addressLookup.right());
+    HostAddress address = std::move(addressLookup.right());
     String cleanAddressString = toString(address);
 
     bool entryFound = false;
@@ -1003,7 +1003,7 @@ void UniverseServer::respondToCelestialRequests() {
         return false;
       });
     if (m_clients.contains(p.first))
-      m_connectionServer->sendPackets(p.first, {make_shared<CelestialResponsePacket>(move(responses))});
+      m_connectionServer->sendPackets(p.first, {make_shared<CelestialResponsePacket>(std::move(responses))});
   }
   eraseWhere(m_pendingCelestialRequests, [](auto const& p) {
       return p.second.empty();
@@ -1062,7 +1062,7 @@ void UniverseServer::handleWorldMessages() {
       auto& world = *worldResult;
 
       if (world)
-        world->passMessages(move(it->second));
+        world->passMessages(std::move(it->second));
       else for (auto& message : it->second)
         message.promise.fail("Error creating world");
 
@@ -1455,14 +1455,14 @@ void UniverseServer::addCelestialRequests(ConnectionId clientId, List<CelestialR
 void UniverseServer::worldUpdated(WorldServerThread* server) {
   for (auto clientId : server->clients()) {
     auto packets = server->pullOutgoingPackets(clientId);
-    m_connectionServer->sendPackets(clientId, move(packets));
+    m_connectionServer->sendPackets(clientId, std::move(packets));
   }
 }
 
 void UniverseServer::systemWorldUpdated(SystemWorldServerThread* systemWorldServer) {
   for (auto clientId : systemWorldServer->clients()) {
     auto packets = systemWorldServer->pullOutgoingPackets(clientId);
-    m_connectionServer->sendPackets(clientId, move(packets));
+    m_connectionServer->sendPackets(clientId, std::move(packets));
   }
 }
 
@@ -1480,23 +1480,23 @@ void UniverseServer::packetsReceived(UniverseConnectionServer*, ConnectionId cli
 
       } else if (auto chatSend = as<ChatSendPacket>(packet)) {
         RecursiveMutexLocker locker(m_mainLock);
-        m_pendingChat[clientId].append({move(chatSend->text), chatSend->sendMode});
+        m_pendingChat[clientId].append({std::move(chatSend->text), chatSend->sendMode});
 
       } else if (auto clientContextUpdatePacket = as<ClientContextUpdatePacket>(packet)) {
-        clientContext->readUpdate(move(clientContextUpdatePacket->updateData));
+        clientContext->readUpdate(std::move(clientContextUpdatePacket->updateData));
 
       } else if (auto clientDisconnectPacket = as<ClientDisconnectRequestPacket>(packet)) {
         disconnectClient(clientId, String());
 
       } else if (auto celestialRequest = as<CelestialRequestPacket>(packet)) {
-        addCelestialRequests(clientId, move(celestialRequest->requests));
+        addCelestialRequests(clientId, std::move(celestialRequest->requests));
 
       } else if (is<SystemObjectSpawnPacket>(packet)) {
         if (auto currentSystem = clientContext->systemWorld())
-          currentSystem->pushIncomingPacket(clientId, move(packet));
+          currentSystem->pushIncomingPacket(clientId, std::move(packet));
       } else {
         if (auto currentWorld = clientContext->playerWorld())
-          currentWorld->pushIncomingPackets(clientId, {move(packet)});
+          currentWorld->pushIncomingPackets(clientId, {std::move(packet)});
       }
     }
   }
@@ -1533,7 +1533,7 @@ void UniverseServer::acceptConnection(UniverseConnection connection, Maybe<HostA
     connection.pushSingle(protocolResponse);
     connection.sendAll(clientWaitLimit);
     mainLocker.lock();
-    m_deadConnections.append({move(connection), Time::monotonicMilliseconds()});
+    m_deadConnections.append({std::move(connection), Time::monotonicMilliseconds()});
     return;
   }
 
@@ -1550,7 +1550,7 @@ void UniverseServer::acceptConnection(UniverseConnection connection, Maybe<HostA
     Logger::warn("UniverseServer: client connection aborted");
     connection.pushSingle(make_shared<ConnectFailurePacket>("connect timeout"));
     mainLocker.lock();
-    m_deadConnections.append({move(connection), Time::monotonicMilliseconds()});
+    m_deadConnections.append({std::move(connection), Time::monotonicMilliseconds()});
     return;
   }
 
@@ -1561,9 +1561,9 @@ void UniverseServer::acceptConnection(UniverseConnection connection, Maybe<HostA
   auto connectionFail = [&](String message) {
     Logger::warn("UniverseServer: Login attempt failed with account '{}' as player '{}' from address {}, error: {}",
         accountString, clientConnect->playerName, remoteAddressString, message);
-    connection.pushSingle(make_shared<ConnectFailurePacket>(move(message)));
+    connection.pushSingle(make_shared<ConnectFailurePacket>(std::move(message)));
     mainLocker.lock();
-    m_deadConnections.append({move(connection), Time::monotonicMilliseconds()});
+    m_deadConnections.append({std::move(connection), Time::monotonicMilliseconds()});
   };
 
   if (!remoteAddress) {
@@ -1672,7 +1672,7 @@ void UniverseServer::acceptConnection(UniverseConnection connection, Maybe<HostA
 
   clientContext->setShipUpgrades(clientConnect->shipUpgrades);
 
-  m_connectionServer->addConnection(clientId, move(connection));
+  m_connectionServer->addConnection(clientId, std::move(connection));
   m_chatProcessor->connectClient(clientId, clientConnect->playerName);
 
   m_connectionServer->sendPackets(clientId, {
diff --git a/source/game/StarVehicle.cpp b/source/game/StarVehicle.cpp
index f8eeef1..a253de1 100644
--- a/source/game/StarVehicle.cpp
+++ b/source/game/StarVehicle.cpp
@@ -13,7 +13,7 @@
 namespace Star {
 
 Vehicle::Vehicle(Json baseConfig, String path, Json dynamicConfig)
-  : m_baseConfig(move(baseConfig)), m_path(move(path)), m_dynamicConfig(move(dynamicConfig)) {
+  : m_baseConfig(std::move(baseConfig)), m_path(std::move(path)), m_dynamicConfig(std::move(dynamicConfig)) {
 
   m_typeName = m_baseConfig.getString("name");
 
@@ -247,7 +247,7 @@ pair<ByteArray, uint64_t> Vehicle::writeNetState(uint64_t fromVersion) {
 }
 
 void Vehicle::readNetState(ByteArray data, float interpolationTime) {
-  m_netGroup.readNetState(move(data), interpolationTime);
+  m_netGroup.readNetState(std::move(data), interpolationTime);
 }
 
 void Vehicle::enableInterpolation(float extrapolationHint) {
@@ -296,7 +296,7 @@ void Vehicle::update(float dt, uint64_t) {
         JsonArray allControlsHeld = transform<JsonArray>(p.second.slaveNewControls, [](LoungeControl control) {
             return LoungeControlNames.getRight(control);
           });
-        world()->sendEntityMessage(entityId(), "control_all", {*m_loungePositions.indexOf(p.first), move(allControlsHeld)});
+        world()->sendEntityMessage(entityId(), "control_all", {*m_loungePositions.indexOf(p.first), std::move(allControlsHeld)});
       } else {
         for (auto control : p.second.slaveNewControls.difference(p.second.slaveOldControls))
           world()->sendEntityMessage(entityId(), "control_on", {*m_loungePositions.indexOf(p.first), LoungeControlNames.getRight(control)});
@@ -323,9 +323,9 @@ void Vehicle::update(float dt, uint64_t) {
 void Vehicle::render(RenderCallback* renderer) {
   for (auto& drawable : m_networkedAnimator.drawablesWithZLevel(position())) {
     if (drawable.second < 0.0f)
-      renderer->addDrawable(move(drawable.first), renderLayer(VehicleLayer::Back));
+      renderer->addDrawable(std::move(drawable.first), renderLayer(VehicleLayer::Back));
     else
-      renderer->addDrawable(move(drawable.first), renderLayer(VehicleLayer::Front));
+      renderer->addDrawable(std::move(drawable.first), renderLayer(VehicleLayer::Front));
   }
 
   renderer->addAudios(m_networkedAnimatorDynamicTarget.pullNewAudios());
@@ -500,7 +500,7 @@ List<PhysicsForceRegion> Vehicle::forceRegions() const {
       }
 
       forceRegion.call([translatePos](auto& fr) { fr.translate(translatePos); });
-      forces.append(move(forceRegion));
+      forces.append(std::move(forceRegion));
     }
   }
   return forces;
@@ -520,7 +520,7 @@ List<DamageSource> Vehicle::damageSources() const {
       damageSource.team = m_damageTeam.get();
       damageSource.sourceEntityId = entityId();
 
-      sources.append(move(damageSource));
+      sources.append(std::move(damageSource));
     }
   }
   return sources;
@@ -597,15 +597,15 @@ LuaCallbacks Vehicle::makeVehicleCallbacks() {
     });
 
   callbacks.registerCallback("setLoungeEmote", [this](String const& name, Maybe<String> emote) {
-      m_loungePositions.get(name).emote.set(move(emote));
+      m_loungePositions.get(name).emote.set(std::move(emote));
     });
 
   callbacks.registerCallback("setLoungeDance", [this](String const& name, Maybe<String> dance) {
-      m_loungePositions.get(name).dance.set(move(dance));
+      m_loungePositions.get(name).dance.set(std::move(dance));
     });
 
   callbacks.registerCallback("setLoungeDirectives", [this](String const& name, Maybe<String> directives) {
-      m_loungePositions.get(name).directives.set(move(directives));
+      m_loungePositions.get(name).directives.set(std::move(directives));
     });
 
   callbacks.registerCallback("setLoungeStatusEffects", [this](String const& name, JsonArray const& statusEffects) {
@@ -641,14 +641,14 @@ LuaCallbacks Vehicle::makeVehicleCallbacks() {
     });
 
   callbacks.registerCallback("setAnimationParameter", [this](String name, Json value) {
-      m_scriptedAnimationParameters.set(move(name), move(value));
+      m_scriptedAnimationParameters.set(std::move(name), std::move(value));
     });
 
   return callbacks;
 }
 
 Json Vehicle::configValue(String const& name, Json def) const {
-  return jsonMergeQueryDef(name, move(def), m_baseConfig, m_dynamicConfig);
+  return jsonMergeQueryDef(name, std::move(def), m_baseConfig, m_dynamicConfig);
 }
 
 }
diff --git a/source/game/StarVehicleDatabase.cpp b/source/game/StarVehicleDatabase.cpp
index 4c22963..a5f923d 100644
--- a/source/game/StarVehicleDatabase.cpp
+++ b/source/game/StarVehicleDatabase.cpp
@@ -18,7 +18,7 @@ VehicleDatabase::VehicleDatabase() {
       if (m_vehicles.contains(name))
         throw VehicleDatabaseException::format("Repeat vehicle name '{}'", name);
 
-      m_vehicles.add(move(name), make_pair(move(file), move(config)));
+      m_vehicles.add(std::move(name), make_pair(std::move(file), std::move(config)));
     } catch (StarException const& e) {
       throw VehicleDatabaseException(strf("Error loading vehicle '{}'", file), e);
     }
diff --git a/source/game/StarWarping.cpp b/source/game/StarWarping.cpp
index 8268b16..bfbf9fd 100644
--- a/source/game/StarWarping.cpp
+++ b/source/game/StarWarping.cpp
@@ -15,7 +15,7 @@ EnumMap<WarpMode> WarpModeNames {
 InstanceWorldId::InstanceWorldId() {}
 
 InstanceWorldId::InstanceWorldId(String instance, Maybe<Uuid> uuid, Maybe<float> level)
-  : instance(move(instance)), uuid(move(uuid)), level(move(level)) {}
+  : instance(std::move(instance)), uuid(std::move(uuid)), level(std::move(level)) {}
 
 bool InstanceWorldId::operator==(InstanceWorldId const& rhs) const {
   return tie(instance, uuid, level) == tie(rhs.instance, rhs.uuid, rhs.level);
@@ -158,7 +158,7 @@ String printSpawnTarget(SpawnTarget spawnTarget) {
 
 WarpToWorld::WarpToWorld() {}
 
-WarpToWorld::WarpToWorld(WorldId world, SpawnTarget target) : world(move(world)), target(move(target)) {}
+WarpToWorld::WarpToWorld(WorldId world, SpawnTarget target) : world(std::move(world)), target(std::move(target)) {}
 
 WarpToWorld::WarpToWorld(Json v) {
   if (v) {
diff --git a/source/game/StarWeather.cpp b/source/game/StarWeather.cpp
index 010893a..6b1c6a7 100644
--- a/source/game/StarWeather.cpp
+++ b/source/game/StarWeather.cpp
@@ -44,7 +44,7 @@ void ServerWeather::setup(WeatherPool weatherPool, float undergroundLevel, World
 }
 
 void ServerWeather::setReferenceClock(ClockConstPtr referenceClock) {
-  m_referenceClock = move(referenceClock);
+  m_referenceClock = std::move(referenceClock);
   if (m_referenceClock)
     m_clockTrackingTime = m_referenceClock->time();
   else
@@ -52,7 +52,7 @@ void ServerWeather::setReferenceClock(ClockConstPtr referenceClock) {
 }
 
 void ServerWeather::setClientVisibleRegions(List<RectI> regions) {
-  m_clientVisibleRegions = move(regions);
+  m_clientVisibleRegions = std::move(regions);
 }
 
 pair<ByteArray, uint64_t> ServerWeather::writeUpdate(uint64_t fromVersion) {
@@ -265,7 +265,7 @@ void ClientWeather::setup(WorldGeometry worldGeometry, WeatherEffectsActiveQuery
 
 void ClientWeather::readUpdate(ByteArray data) {
   if (!data.empty()) {
-    m_netGroup.readNetState(move(data));
+    m_netGroup.readNetState(std::move(data));
     getNetStates();
   }
 }
@@ -352,7 +352,7 @@ void ClientWeather::spawnWeatherParticles(RectF newClientRegion, float dt) {
         if (y > m_undergroundLevel && (!m_weatherEffectsActiveQuery || m_weatherEffectsActiveQuery(Vec2I::floor(newParticle.position)))) {
           if (particleConfig.autoRotate)
             newParticle.rotation += angleChange;
-          m_particles.append(move(newParticle));
+          m_particles.append(std::move(newParticle));
         }
       }
     }
diff --git a/source/game/StarWeatherTypes.cpp b/source/game/StarWeatherTypes.cpp
index 5cb12e8..9108dc3 100644
--- a/source/game/StarWeatherTypes.cpp
+++ b/source/game/StarWeatherTypes.cpp
@@ -24,7 +24,7 @@ WeatherType::WeatherType(Json config, String path) {
     config.particle = Particle(v.get("particle"), path);
     config.density = v.getFloat("density");
     config.autoRotate = v.getBool("autoRotate", false);
-    particles.append(move(config));
+    particles.append(std::move(config));
   }
 
   for (auto v : config.getArray("projectiles", JsonArray())) {
@@ -36,7 +36,7 @@ WeatherType::WeatherType(Json config, String path) {
     config.spawnAboveRegion = v.getInt("spawnAboveRegion");
     config.spawnHorizontalPad = v.getInt("spawnHorizontalPad");
     config.windAffectAmount = v.getFloat("windAffectAmount", 0.0f);
-    projectiles.append(move(config));
+    projectiles.append(std::move(config));
   }
 
   maximumWind = config.getFloat("maximumWind", 0.0f);
diff --git a/source/game/StarWorldClient.cpp b/source/game/StarWorldClient.cpp
index b2a79fb..b4244b0 100644
--- a/source/game/StarWorldClient.cpp
+++ b/source/game/StarWorldClient.cpp
@@ -163,13 +163,13 @@ void WorldClient::removeEntity(EntityId entityId, bool andDie) {
         p.directives.append(directives->get(directiveIndex));
     }
 
-    m_particles->addParticles(move(renderCallback.particles));
-    m_samples.appendAll(move(renderCallback.audios));
+    m_particles->addParticles(std::move(renderCallback.particles));
+    m_samples.appendAll(std::move(renderCallback.audios));
   }
 
   if (auto version = m_masterEntitiesNetVersion.maybeTake(entity->entityId())) {
     ByteArray finalNetState = entity->writeNetState(*version).first;
-    m_outgoingPackets.append(make_shared<EntityDestroyPacket>(entity->entityId(), move(finalNetState), andDie));
+    m_outgoingPackets.append(make_shared<EntityDestroyPacket>(entity->entityId(), std::move(finalNetState), andDie));
   }
 
   m_entityMap->removeEntity(entityId);
@@ -356,7 +356,7 @@ TileModificationList WorldClient::applyTileModifications(TileModificationList co
       failures.append(pair);
     }
     if (yay) {
-      list = &(temp = move(failures));
+      list = &(temp = std::move(failures));
       failures = {};
       continue;
     }
@@ -364,7 +364,7 @@ TileModificationList WorldClient::applyTileModifications(TileModificationList co
   }
 
   if (!success.empty())
-    m_outgoingPackets.append(make_shared<ModifyTileListPacket>(move(success), true));
+    m_outgoingPackets.append(make_shared<ModifyTileListPacket>(std::move(success), true));
 
   return failures;
 }
@@ -440,7 +440,7 @@ void WorldClient::render(WorldRenderData& renderData, unsigned bufferTiles) {
     entity->renderLightSources(&lightingRenderCallback);
   });
 
-  renderLightSources = move(lightingRenderCallback.lightSources);
+  renderLightSources = std::move(lightingRenderCallback.lightSources);
 
   RectI window = m_clientState.window();
   RectI tileRange = window.padded(bufferTiles);
@@ -519,7 +519,7 @@ void WorldClient::render(WorldRenderData& renderData, unsigned bufferTiles) {
               d.imagePart().addDirectives(directives->at(directiveIndex), true);
           }
         }
-        ed.layers[p.first] = move(p.second); 
+        ed.layers[p.first] = std::move(p.second);
       }
 
       if (m_interactiveHighlightMode || (!inspecting && entity->entityId() == playerAimInteractive)) {
@@ -535,7 +535,7 @@ void WorldClient::render(WorldRenderData& renderData, unsigned bufferTiles) {
           ed.highlightEffect.level *= inspectionFlickerMultiplier;
         }
       }
-      renderData.entityDrawables.append(move(ed));
+      renderData.entityDrawables.append(std::move(ed));
 
       if (directives) {
         int directiveIndex = unsigned(entity->entityId()) % directives->size();
@@ -543,10 +543,10 @@ void WorldClient::render(WorldRenderData& renderData, unsigned bufferTiles) {
           p.directives.append(directives->get(directiveIndex));
       }
       
-      m_particles->addParticles(move(renderCallback.particles));
-      m_samples.appendAll(move(renderCallback.audios));
-      previewTiles.appendAll(move(renderCallback.previewTiles));
-      renderData.overheadBars.appendAll(move(renderCallback.overheadBars));
+      m_particles->addParticles(std::move(renderCallback.particles));
+      m_samples.appendAll(std::move(renderCallback.audios));
+      previewTiles.appendAll(std::move(renderCallback.previewTiles));
+      renderData.overheadBars.appendAll(std::move(renderCallback.overheadBars));
 
     }, [](EntityPtr const& a, EntityPtr const& b) {
       return a->entityId() < b->entityId();
@@ -1141,7 +1141,7 @@ void WorldClient::update(float dt) {
     });
 
   m_clientState.setPlayer(m_mainPlayer->entityId());
-  m_clientState.setClientPresenceEntities(move(clientPresenceEntities));
+  m_clientState.setClientPresenceEntities(std::move(clientPresenceEntities));
 
   m_damageManager->update(dt);
   handleDamageNotifications();
@@ -1345,12 +1345,12 @@ TileDamageResult WorldClient::damageTiles(List<Vec2I> const& pos, TileLayer laye
   if (toDing.size()) {
     auto dingDamage = tileDamage;
     dingDamage.type = TileDamageType::Protected;
-    m_outgoingPackets.append(make_shared<DamageTileGroupPacket>(move(toDing), layer, sourcePosition, dingDamage, Maybe<EntityId>()));
+    m_outgoingPackets.append(make_shared<DamageTileGroupPacket>(std::move(toDing), layer, sourcePosition, dingDamage, Maybe<EntityId>()));
     res = TileDamageResult::Protected;
   }
 
   if (toDamage.size()) {
-    m_outgoingPackets.append(make_shared<DamageTileGroupPacket>(move(toDamage), layer, sourcePosition, tileDamage, sourceEntity));
+    m_outgoingPackets.append(make_shared<DamageTileGroupPacket>(std::move(toDamage), layer, sourcePosition, tileDamage, sourceEntity));
     res = TileDamageResult::Normal;
   }
 
@@ -1405,7 +1405,7 @@ void WorldClient::collectLiquid(List<Vec2I> const& tilePositions, LiquidId liqui
 void WorldClient::waitForLighting(Image* out) {
   MutexLocker lock(m_lightMapMutex);
   if (out)
-    *out = move(m_lightMap);
+    *out = std::move(m_lightMap);
 }
 
 WorldClient::BroadcastCallback& WorldClient::broadcastCallback() {
@@ -1447,19 +1447,19 @@ void WorldClient::queueUpdatePackets() {
         if (auto version = m_masterEntitiesNetVersion.ptr(entity->entityId())) {
           auto updateAndVersion = entity->writeNetState(*version);
           if (!updateAndVersion.first.empty())
-            entityUpdateSet->deltas[entity->entityId()] = move(updateAndVersion.first);
+            entityUpdateSet->deltas[entity->entityId()] = std::move(updateAndVersion.first);
           *version = updateAndVersion.second;
         }
       });
-    m_outgoingPackets.append(move(entityUpdateSet));
+    m_outgoingPackets.append(std::move(entityUpdateSet));
   }
 
   for (auto& remoteHitRequest : m_damageManager->pullRemoteHitRequests())
-    m_outgoingPackets.append(make_shared<HitRequestPacket>(move(remoteHitRequest)));
+    m_outgoingPackets.append(make_shared<HitRequestPacket>(std::move(remoteHitRequest)));
   for (auto& remoteDamageRequest : m_damageManager->pullRemoteDamageRequests())
-    m_outgoingPackets.append(make_shared<DamageRequestPacket>(move(remoteDamageRequest)));
+    m_outgoingPackets.append(make_shared<DamageRequestPacket>(std::move(remoteDamageRequest)));
   for (auto& remoteDamageNotification : m_damageManager->pullRemoteDamageNotifications())
-    m_outgoingPackets.append(make_shared<DamageNotificationPacket>(move(remoteDamageNotification)));
+    m_outgoingPackets.append(make_shared<DamageNotificationPacket>(std::move(remoteDamageNotification)));
 }
 
 void WorldClient::handleDamageNotifications() {
@@ -1642,7 +1642,7 @@ void WorldClient::lightingTileGather() {
         if (tile.backgroundLightTransparent && pos[1] + y > undergroundLevel)
           light += environmentLight;
       }
-      m_lightingCalculator.setCellIndex(baseIndex + y, move(light), !tile.foregroundLightTransparent);
+      m_lightingCalculator.setCellIndex(baseIndex + y, std::move(light), !tile.foregroundLightTransparent);
     }
   });
 }
@@ -1811,7 +1811,7 @@ void WorldClient::notifyEntityCreate(EntityPtr const& entity) {
     auto firstNetState = entity->writeNetState();
     m_masterEntitiesNetVersion[entity->entityId()] = firstNetState.second;
     m_outgoingPackets.append(make_shared<EntityCreatePacket>(entity->entityType(),
-      Root::singleton().entityFactory()->netStoreEntity(entity), move(firstNetState.first), entity->entityId()));
+      Root::singleton().entityFactory()->netStoreEntity(entity), std::move(firstNetState.first), entity->entityId()));
   }
 }
 
@@ -1839,7 +1839,7 @@ WeatherNoisesDescriptionPtr WorldClient::currentWeatherNoises() const {
   if (trackOptions.empty())
     return {};
   else
-    return make_shared<WeatherNoisesDescription>(move(trackOptions));
+    return make_shared<WeatherNoisesDescription>(std::move(trackOptions));
 }
 
 AmbientNoisesDescriptionPtr WorldClient::currentMusicTrack() const {
@@ -1984,7 +1984,7 @@ void WorldClient::freshenCollision(RectI const& region) {
 
     for (auto& collisionBlock : m_collisionGenerator.getBlocks(freshenRegion)) {
       if (auto tile = m_tileArray->modifyTile(collisionBlock.space))
-        tile->collisionCache.append(move(collisionBlock));
+        tile->collisionCache.append(std::move(collisionBlock));
     }
   }
 }
@@ -2109,7 +2109,7 @@ bool WorldClient::sendSecretBroadcast(StringView broadcast, bool raw, bool compr
   if (!compress)
     damageNotification->setCompressionMode(PacketCompressionMode::Disabled);
 
-  m_outgoingPackets.emplace_back(move(damageNotification));
+  m_outgoingPackets.emplace_back(std::move(damageNotification));
   return true;
 }
 
@@ -2122,27 +2122,27 @@ bool WorldClient::handleSecretBroadcast(PlayerPtr player, StringView broadcast)
 
 
 void WorldClient::ClientRenderCallback::addDrawable(Drawable drawable, EntityRenderLayer renderLayer) {
-  drawables[renderLayer].append(move(drawable));
+  drawables[renderLayer].append(std::move(drawable));
 }
 
 void WorldClient::ClientRenderCallback::addLightSource(LightSource lightSource) {
-  lightSources.append(move(lightSource));
+  lightSources.append(std::move(lightSource));
 }
 
 void WorldClient::ClientRenderCallback::addParticle(Particle particle) {
-  particles.append(move(particle));
+  particles.append(std::move(particle));
 }
 
 void WorldClient::ClientRenderCallback::addAudio(AudioInstancePtr audio) {
-  audios.append(move(audio));
+  audios.append(std::move(audio));
 }
 
 void WorldClient::ClientRenderCallback::addTilePreview(PreviewTile preview) {
-  previewTiles.append(move(preview));
+  previewTiles.append(std::move(preview));
 }
 
 void WorldClient::ClientRenderCallback::addOverheadBar(OverheadBar bar) {
-  overheadBars.append(move(bar));
+  overheadBars.append(std::move(bar));
 }
 
 double WorldClient::epochTime() const {
diff --git a/source/game/StarWorldClientState.cpp b/source/game/StarWorldClientState.cpp
index 978c115..5dc6b12 100644
--- a/source/game/StarWorldClientState.cpp
+++ b/source/game/StarWorldClientState.cpp
@@ -52,7 +52,7 @@ List<EntityId> const& WorldClientState::clientPresenceEntities() const {
 }
 
 void WorldClientState::setClientPresenceEntities(List<EntityId> entities) {
-  m_clientPresenceEntities.set(move(entities));
+  m_clientPresenceEntities.set(std::move(entities));
 }
 
 List<RectI> WorldClientState::monitoringRegions(function<Maybe<RectI>(EntityId)> entityBounds) const {
@@ -84,7 +84,7 @@ ByteArray WorldClientState::writeDelta() {
 }
 
 void WorldClientState::readDelta(ByteArray delta) {
-  m_netGroup.readNetState(move(delta));
+  m_netGroup.readNetState(std::move(delta));
 }
 
 void WorldClientState::reset() {
diff --git a/source/game/StarWorldGeneration.cpp b/source/game/StarWorldGeneration.cpp
index 301df08..55a3b46 100644
--- a/source/game/StarWorldGeneration.cpp
+++ b/source/game/StarWorldGeneration.cpp
@@ -702,7 +702,7 @@ bool WorldGenerator::entityPersistent(WorldStorage*, EntityPtr const& entity) co
 RpcPromise<Vec2I> WorldGenerator::enqueuePlacement(List<BiomeItemDistribution> distributions, Maybe<DungeonId> id) {
   auto promise = RpcPromise<Vec2I>::createPair();
   m_queuedPlacements.append(QueuedPlacement {
-    move(distributions),
+    std::move(distributions),
     id,
     promise.second,
     false,
@@ -829,7 +829,7 @@ void WorldGenerator::generateMicroDungeons(WorldStorage* worldStorage, ServerTil
         m_worldServer->worldTemplate()->addPotentialBiomeItems(x, y, queuedItems, p.distributions, BiomePlacementArea::Surface);
         m_worldServer->worldTemplate()->addPotentialBiomeItems(x, y, queuedItems, p.distributions, BiomePlacementArea::Underground);
         for (auto placement : m_worldServer->worldTemplate()->validBiomeItems(x, y, queuedItems))
-          placementQueue.append({move(placement), &p});
+          placementQueue.append({std::move(placement), &p});
       }
     }
   }
diff --git a/source/game/StarWorldParameters.cpp b/source/game/StarWorldParameters.cpp
index d0fc646..97f0611 100644
--- a/source/game/StarWorldParameters.cpp
+++ b/source/game/StarWorldParameters.cpp
@@ -471,7 +471,7 @@ VisitableWorldParametersPtr netLoadVisitableWorldParameters(ByteArray data) {
   if (data.empty())
     return {};
 
-  DataStreamBuffer ds(move(data));
+  DataStreamBuffer ds(std::move(data));
   auto type = ds.read<WorldParametersType>();
 
   VisitableWorldParametersPtr parameters;
diff --git a/source/game/StarWorldServer.cpp b/source/game/StarWorldServer.cpp
index a722b5a..f8acc18 100644
--- a/source/game/StarWorldServer.cpp
+++ b/source/game/StarWorldServer.cpp
@@ -82,7 +82,7 @@ WorldServer::~WorldServer() {
 }
 
 void WorldServer::setWorldId(String worldId) {
-  m_worldId = move(worldId);
+  m_worldId = std::move(worldId);
 }
 
 String const& WorldServer::worldId() const {
@@ -90,7 +90,7 @@ String const& WorldServer::worldId() const {
 }
 
 void WorldServer::setUniverseSettings(UniverseSettingsPtr universeSettings) {
-  m_universeSettings = move(universeSettings);
+  m_universeSettings = std::move(universeSettings);
 }
 
 UniverseSettingsPtr WorldServer::universeSettings() const {
@@ -117,7 +117,7 @@ void WorldServer::initLua(UniverseServer* universe) {
 WorldStructure WorldServer::setCentralStructure(WorldStructure centralStructure) {
   removeCentralStructure();
 
-  m_centralStructure = move(centralStructure);
+  m_centralStructure = std::move(centralStructure);
   m_centralStructure.setAnchorPosition(Vec2I(m_geometry.size()) / 2);
 
   m_playerStart = Vec2F(m_centralStructure.flaggedBlocks("playerSpawn").first()) + Vec2F(0, 1);
@@ -286,7 +286,7 @@ List<PacketPtr> WorldServer::removeClient(ConnectionId clientId) {
     }
   }
 
-  auto packets = move(info->outgoingPackets);
+  auto packets = std::move(info->outgoingPackets);
   m_clientInfo.remove(clientId);
 
   packets.append(make_shared<WorldStopPacket>("Removed"));
@@ -367,9 +367,9 @@ void WorldServer::handleIncomingPackets(ConnectionId clientId, List<PacketPtr> c
         clientInfo->outgoingPackets.append(make_shared<GiveItemPacket>(item));
 
     } else if (auto sepacket = as<SpawnEntityPacket>(packet)) {
-      auto entity = entityFactory->netLoadEntity(sepacket->entityType, move(sepacket->storeData));
-      entity->readNetState(move(sepacket->firstNetState));
-      addEntity(move(entity));
+      auto entity = entityFactory->netLoadEntity(sepacket->entityType, std::move(sepacket->storeData));
+      entity->readNetState(std::move(sepacket->firstNetState));
+      addEntity(std::move(entity));
 
     } else if (auto rdpacket = as<RequestDropPacket>(packet)) {
       auto drop = m_entityMap->get<ItemDrop>(rdpacket->dropEntityId);
@@ -489,7 +489,7 @@ void WorldServer::handleIncomingPackets(ConnectionId clientId, List<PacketPtr> c
         } else if (auto const& clientInfo = m_clientInfo.value(connectionForEntity(entity->entityId()))) {
           m_entityMessageResponses[entityMessagePacket->uuid] = {clientInfo->clientId, clientId};
           entityMessagePacket->fromConnection = clientId;
-          clientInfo->outgoingPackets.append(move(entityMessagePacket));
+          clientInfo->outgoingPackets.append(std::move(entityMessagePacket));
         }
       }
 
@@ -500,7 +500,7 @@ void WorldServer::handleIncomingPackets(ConnectionId clientId, List<PacketPtr> c
       auto response = m_entityMessageResponses.take(entityMessageResponsePacket->uuid).second;
       if (response.is<ConnectionId>()) {
         if (auto clientInfo = m_clientInfo.value(response.get<ConnectionId>()))
-          clientInfo->outgoingPackets.append(move(entityMessageResponsePacket));
+          clientInfo->outgoingPackets.append(std::move(entityMessageResponsePacket));
       } else {
         if (entityMessageResponsePacket->response.isRight())
           response.get<RpcPromiseKeeper<Json>>().fulfill(entityMessageResponsePacket->response.right());
@@ -529,7 +529,7 @@ void WorldServer::handleIncomingPackets(ConnectionId clientId, List<PacketPtr> c
 
 List<PacketPtr> WorldServer::getOutgoingPackets(ConnectionId clientId) {
   auto const& clientInfo = m_clientInfo.get(clientId);
-  return move(clientInfo->outgoingPackets);
+  return std::move(clientInfo->outgoingPackets);
 }
 
 Maybe<Json> WorldServer::receiveMessage(ConnectionId fromConnection, String const& message, JsonArray const& args) {
@@ -624,7 +624,7 @@ void WorldServer::update(float dt) {
   m_weather.setClientVisibleRegions(clientWindows);
   m_weather.update(dt);
   for (auto projectile : m_weather.pullNewProjectiles())
-    addEntity(move(projectile));
+    addEntity(std::move(projectile));
 
   if (shouldRunThisStep("liquidUpdate")) {
     m_liquidEngine->setProcessingLimit(m_fidelityConfig.optUInt("liquidEngineBackgroundProcessingLimit"));
@@ -1563,14 +1563,14 @@ void WorldServer::updateTileEntityTiles(TileEntityPtr const& entity, bool removi
       if (updated)
         queueTileUpdates(pos);
     }
-    spaces.materials = move(passedSpaces);
+    spaces.materials = std::move(passedSpaces);
 
     // add new roots and update known roots entry
     for (auto const& rootPos : newRoots) {
       if (auto tile = m_tileArray->modifyTile(rootPos + entity->tilePosition()))
         tile->rootSource = entity->tilePosition();
     }
-    spaces.roots = move(newRoots);
+    spaces.roots = std::move(newRoots);
   }
 
   // check whether we've broken any other nearby entities
@@ -1622,7 +1622,7 @@ WorldServer::ScriptComponentPtr WorldServer::scriptContext(String const& context
 }
 
 RpcPromise<Vec2I> WorldServer::enqueuePlacement(List<BiomeItemDistribution> distributions, Maybe<DungeonId> id) {
-  return m_worldStorage->enqueuePlacement(move(distributions), id);
+  return m_worldStorage->enqueuePlacement(std::move(distributions), id);
 }
 
 ServerTile const& WorldServer::getServerTile(Vec2I const& position, bool withSignal) {
@@ -1774,7 +1774,7 @@ void WorldServer::queueUpdatePackets(ConnectionId clientId) {
     tie(weatherDelta, clientInfo->weatherNetVersion) = m_weather.writeUpdate(clientInfo->weatherNetVersion);
 
     if (!skyDelta.empty() || !weatherDelta.empty())
-      clientInfo->outgoingPackets.append(make_shared<EnvironmentUpdatePacket>(move(skyDelta), move(weatherDelta)));
+      clientInfo->outgoingPackets.append(make_shared<EnvironmentUpdatePacket>(std::move(skyDelta), std::move(weatherDelta)));
   }
 
   for (auto sector : clientInfo->pendingSectors.values()) {
@@ -1861,13 +1861,13 @@ void WorldServer::queueUpdatePackets(ConnectionId clientId) {
         auto firstUpdate = monitoredEntity->writeNetState();
         clientInfo->clientSlavesNetVersion.add(entityId, firstUpdate.second);
         clientInfo->outgoingPackets.append(make_shared<EntityCreatePacket>(monitoredEntity->entityType(),
-              entityFactory->netStoreEntity(monitoredEntity), move(firstUpdate.first), entityId));
+              entityFactory->netStoreEntity(monitoredEntity), std::move(firstUpdate.first), entityId));
       }
     }
   }
 
   for (auto& p : updateSetPackets)
-    clientInfo->outgoingPackets.append(move(p.second));
+    clientInfo->outgoingPackets.append(std::move(p.second));
 }
 
 void WorldServer::updateDamage(float dt) {
@@ -2035,7 +2035,7 @@ void WorldServer::freshenCollision(RectI const& region) {
 
     for (auto collisionBlock : m_collisionGenerator.getBlocks(freshenRegion)) {
       if (auto tile = m_tileArray->modifyTile(collisionBlock.space))
-        tile->collisionCache.append(move(collisionBlock));
+        tile->collisionCache.append(std::move(collisionBlock));
     }
   }
 }
@@ -2055,7 +2055,7 @@ void WorldServer::removeEntity(EntityId entityId, bool andDie) {
     auto& clientInfo = pair.second;
     if (auto version = clientInfo->clientSlavesNetVersion.maybeTake(entity->entityId())) {
       ByteArray finalDelta = entity->writeNetState(*version).first;
-      clientInfo->outgoingPackets.append(make_shared<EntityDestroyPacket>(entity->entityId(), move(finalDelta), andDie));
+      clientInfo->outgoingPackets.append(make_shared<EntityDestroyPacket>(entity->entityId(), std::move(finalDelta), andDie));
     }
   }
 
diff --git a/source/game/StarWorldServerThread.cpp b/source/game/StarWorldServerThread.cpp
index 35d6225..c03c938 100644
--- a/source/game/StarWorldServerThread.cpp
+++ b/source/game/StarWorldServerThread.cpp
@@ -10,8 +10,8 @@ namespace Star {
 
 WorldServerThread::WorldServerThread(WorldServerPtr server, WorldId worldId)
   : Thread("WorldServerThread: " + printWorldId(worldId)),
-    m_worldServer(move(server)),
-    m_worldId(move(worldId)),
+    m_worldServer(std::move(server)),
+    m_worldId(std::move(worldId)),
     m_stop(false),
     m_errorOccurred(false),
     m_shouldExpire(true) {
@@ -93,7 +93,7 @@ List<PacketPtr> WorldServerThread::removeClient(ConnectionId clientId) {
   try {
     auto incomingPackets = take(m_incomingPacketQueue[clientId]);
     if (m_worldServer->hasClient(clientId))
-      m_worldServer->handleIncomingPackets(clientId, move(incomingPackets));
+      m_worldServer->handleIncomingPackets(clientId, std::move(incomingPackets));
 
     outgoingPackets = take(m_outgoingPacketQueue[clientId]);
     if (m_worldServer->hasClient(clientId))
@@ -134,7 +134,7 @@ List<ConnectionId> WorldServerThread::erroredClients() const {
 
 void WorldServerThread::pushIncomingPackets(ConnectionId clientId, List<PacketPtr> packets) {
   RecursiveMutexLocker queueLocker(m_queueMutex);
-  m_incomingPacketQueue[clientId].appendAll(move(packets));
+  m_incomingPacketQueue[clientId].appendAll(std::move(packets));
 }
 
 List<PacketPtr> WorldServerThread::pullOutgoingPackets(ConnectionId clientId) {
@@ -178,7 +178,7 @@ void WorldServerThread::setUpdateAction(WorldServerAction updateAction) {
 
 void WorldServerThread::passMessages(List<Message>&& messages) {
   RecursiveMutexLocker locker(m_messageMutex);
-  m_messages.appendAll(move(messages));
+  m_messages.appendAll(std::move(messages));
 }
 
 WorldChunks WorldServerThread::readChunks() {
@@ -257,7 +257,7 @@ void WorldServerThread::update(WorldServerFidelity fidelity) {
     auto incomingPackets = take(m_incomingPacketQueue[clientId]);
     queueLocker.unlock();
     try {
-      m_worldServer->handleIncomingPackets(clientId, move(incomingPackets));
+      m_worldServer->handleIncomingPackets(clientId, std::move(incomingPackets));
     } catch (std::exception const& e) {
       Logger::error("WorldServerThread exception caught handling incoming packets for client {}: {}",
           clientId, outputException(e, true));
@@ -275,7 +275,7 @@ void WorldServerThread::update(WorldServerFidelity fidelity) {
   List<Message> messages;
   {
     RecursiveMutexLocker locker(m_messageMutex);
-    messages = move(m_messages);
+    messages = std::move(m_messages);
   }
   for (auto& message : messages) {
     if (auto resp = m_worldServer->receiveMessage(ServerConnectionId, message.message, message.args))
@@ -287,7 +287,7 @@ void WorldServerThread::update(WorldServerFidelity fidelity) {
   for (auto& clientId : unerroredClientIds) {
     auto outgoingPackets = m_worldServer->getOutgoingPackets(clientId);
     RecursiveMutexLocker queueLocker(m_queueMutex);
-    m_outgoingPacketQueue[clientId].appendAll(move(outgoingPackets));
+    m_outgoingPacketQueue[clientId].appendAll(std::move(outgoingPackets));
   }
 
   m_shouldExpire = m_worldServer->shouldExpire();
diff --git a/source/game/StarWorldStorage.cpp b/source/game/StarWorldStorage.cpp
index 869a830..08cf55c 100644
--- a/source/game/StarWorldStorage.cpp
+++ b/source/game/StarWorldStorage.cpp
@@ -45,7 +45,7 @@ WorldChunks WorldStorage::getWorldChunksFromFile(String const& file) {
   openDatabase(db, File::open(file, IOMode::Read));
 
   WorldChunks chunks;
-  db.forAll([&chunks](ByteArray key, ByteArray value) { chunks.add(move(key), move(value)); });
+  db.forAll([&chunks](ByteArray key, ByteArray value) { chunks.add(std::move(key), std::move(value)); });
   return chunks;
 }
 
@@ -203,7 +203,7 @@ void WorldStorage::triggerTerraformSector(Sector sector) {
 }
 
 RpcPromise<Vec2I> WorldStorage::enqueuePlacement(List<BiomeItemDistribution> distributions, Maybe<DungeonId> id) {
-  return m_generatorFacade->enqueuePlacement(move(distributions), id);
+  return m_generatorFacade->enqueuePlacement(std::move(distributions), id);
 }
 
 Maybe<float> WorldStorage::sectorTimeToLive(Sector sector) const {
@@ -405,7 +405,7 @@ WorldChunks WorldStorage::readChunks() {
 
     WorldChunks chunks;
     m_db.forAll([&chunks](ByteArray k, ByteArray v) {
-        chunks.add(move(k), move(v));
+        chunks.add(std::move(k), std::move(v));
       });
 
     return WorldChunks(chunks);
@@ -578,7 +578,7 @@ ByteArray WorldStorage::writeSectorUniqueStore(SectorUniqueStore const& store) {
 void WorldStorage::openDatabase(BTreeDatabase& db, IODevicePtr device) {
   db.setContentIdentifier("World4");
   db.setKeySize(5);
-  db.setIODevice(move(device));
+  db.setIODevice(std::move(device));
   db.setBlockSize(2048);
   db.setAutoCommit(false);
   db.open();
@@ -740,9 +740,9 @@ void WorldStorage::unloadSectorToLevel(Sector const& sector, SectorLoadLevel tar
       return;
 
     if (m_generatorFacade->entityPersistent(this, entity))
-      entitiesToStore.append(move(entity));
+      entitiesToStore.append(std::move(entity));
     else
-      entitiesToRemove.append(move(entity));
+      entitiesToRemove.append(std::move(entity));
   }
 
   for (auto const& entity : entitiesToRemove) {
diff --git a/source/game/StarWorldStructure.cpp b/source/game/StarWorldStructure.cpp
index 110d28b..26ad976 100644
--- a/source/game/StarWorldStructure.cpp
+++ b/source/game/StarWorldStructure.cpp
@@ -74,7 +74,7 @@ WorldStructure::WorldStructure(String const& configPath) {
         blockKeyConfig.getObject("objectParameters", JsonObject()),
         blockKeyConfig.getBool("objectResidual", false),
         jsonToStringList(blockKeyConfig.get("flags", JsonArray()))};
-    blockKeys[jsonToColor(blockKeyConfig.get("value")).toRgba()] = move(blockKey);
+    blockKeys[jsonToColor(blockKeyConfig.get("value")).toRgba()] = std::move(blockKey);
   }
 
   Maybe<Vec2I> anchorPosition;
diff --git a/source/game/StarWorldTemplate.cpp b/source/game/StarWorldTemplate.cpp
index 38d17de..2755b1f 100644
--- a/source/game/StarWorldTemplate.cpp
+++ b/source/game/StarWorldTemplate.cpp
@@ -538,19 +538,19 @@ List<BiomeItemPlacement> WorldTemplate::validBiomeItems(int x, int y, PotentialB
   auto blockBelow = getBlockInfo(x, y - 1);
 
   if (!blockBelow.biomeTransition && blockBelow.terrain && !block.terrain && !blockBelow.foregroundCave)
-    biomeItems.appendAll(move(potentialBiomeItems.surfaceBiomeItems));
+    biomeItems.appendAll(std::move(potentialBiomeItems.surfaceBiomeItems));
 
   if (!blockBelow.biomeTransition && blockBelow.terrain && block.terrain && !blockBelow.foregroundCave && block.foregroundCave)
-    biomeItems.appendAll(move(potentialBiomeItems.caveSurfaceBiomeItems));
+    biomeItems.appendAll(std::move(potentialBiomeItems.caveSurfaceBiomeItems));
 
   if (!blockAbove.biomeTransition && blockAbove.terrain && block.terrain && !blockAbove.foregroundCave && block.foregroundCave)
-    biomeItems.appendAll(move(potentialBiomeItems.caveCeilingBiomeItems));
+    biomeItems.appendAll(std::move(potentialBiomeItems.caveCeilingBiomeItems));
 
   if (block.terrain && block.foregroundCave && !block.backgroundCave)
-    biomeItems.appendAll(move(potentialBiomeItems.caveBackgroundBiomeItems));
+    biomeItems.appendAll(std::move(potentialBiomeItems.caveBackgroundBiomeItems));
 
   if (block.oceanLiquid != EmptyLiquidId && y == block.oceanLiquidLevel)
-    biomeItems.appendAll(move(potentialBiomeItems.oceanItems));
+    biomeItems.appendAll(std::move(potentialBiomeItems.oceanItems));
 
   return biomeItems;
 }
diff --git a/source/game/interfaces/StarWorld.cpp b/source/game/interfaces/StarWorld.cpp
index 5f416df..3c3afae 100644
--- a/source/game/interfaces/StarWorld.cpp
+++ b/source/game/interfaces/StarWorld.cpp
@@ -33,7 +33,7 @@ List<TileEntityPtr> World::entitiesAtTile(Vec2I const& pos, EntityFilter selecto
   List<TileEntityPtr> list;
   forEachEntityAtTile(pos, [&](TileEntityPtr entity) {
       if (!selector || selector(entity))
-        list.append(move(entity));
+        list.append(std::move(entity));
     });
   return list;
 }
diff --git a/source/game/interfaces/StarWorld.hpp b/source/game/interfaces/StarWorld.hpp
index 9c97be5..e1986fa 100644
--- a/source/game/interfaces/StarWorld.hpp
+++ b/source/game/interfaces/StarWorld.hpp
@@ -216,7 +216,7 @@ List<shared_ptr<EntityT>> World::query(RectF const& boundBox, EntityFilterOf<Ent
   forEachEntity(boundBox, [&](EntityPtr const& entity) {
       if (auto e = as<EntityT>(entity)) {
         if (!selector || selector(e))
-          list.append(move(e));
+          list.append(std::move(e));
       }
     });
 
@@ -239,9 +239,9 @@ List<shared_ptr<EntityT>> World::lineQuery(
     Vec2F const& begin, Vec2F const& end, EntityFilterOf<EntityT> selector) const {
   List<shared_ptr<EntityT>> list;
   forEachEntityLine(begin, end, [&](EntityPtr entity) {
-      if (auto e = as<EntityT>(move(entity))) {
+      if (auto e = as<EntityT>(std::move(entity))) {
         if (!selector || selector(e))
-          list.append(move(e));
+          list.append(std::move(e));
       }
     });
 
@@ -253,7 +253,7 @@ List<shared_ptr<EntityT>> World::atTile(Vec2I const& pos) const {
   List<shared_ptr<EntityT>> list;
   forEachEntityAtTile(pos, [&](TileEntityPtr const& entity) {
       if (auto e = as<EntityT>(entity))
-        list.append(move(e));
+        list.append(std::move(e));
     });
   return list;
 }
diff --git a/source/game/items/StarActiveItem.cpp b/source/game/items/StarActiveItem.cpp
index 49e82be..102ad16 100644
--- a/source/game/items/StarActiveItem.cpp
+++ b/source/game/items/StarActiveItem.cpp
@@ -182,7 +182,7 @@ List<DamageSource> ActiveItem::damageSources() const {
         line.flipHorizontal(0.0f);
       line.translate(handPosition(Vec2F()));
     }
-    damageSources.append(move(ds));
+    damageSources.append(std::move(ds));
   }
   return damageSources;
 }
@@ -194,7 +194,7 @@ List<PolyF> ActiveItem::shieldPolys() const {
     if (owner()->facingDirection() == Direction::Left)
       sp.flipHorizontal(0.0f);
     sp.translate(handPosition(Vec2F()));
-    shieldPolys.append(move(sp));
+    shieldPolys.append(std::move(sp));
   }
   return shieldPolys;
 }
@@ -213,7 +213,7 @@ List<PhysicsForceRegion> ActiveItem::forceRegions() const {
         rfr->center[0] *= -1;
       rfr->center += owner()->position() + handPosition(Vec2F());
     }
-    forceRegions.append(move(fr));
+    forceRegions.append(std::move(fr));
   }
   return forceRegions;
 }
@@ -276,7 +276,7 @@ List<LightSource> ActiveItem::lights() const {
       else
         light.beamAngle = -Constants::pi / 2 - constrainAngle(light.beamAngle + Constants::pi / 2);
     }
-    result.append(move(light));
+    result.append(std::move(light));
   }
   result.appendAll(m_scriptedAnimator.lightSources());
   return result;
@@ -294,7 +294,7 @@ List<AudioInstancePtr> ActiveItem::pullNewAudios() {
   for (auto& audio : m_itemAnimatorDynamicTarget.pullNewAudios()) {
     m_activeAudio[audio] = *audio->position();
     audio->setPosition(owner()->position() + handPosition(*audio->position()));
-    result.append(move(audio));
+    result.append(std::move(audio));
   }
   result.appendAll(m_scriptedAnimator.pullNewAudios());
   return result;
@@ -310,7 +310,7 @@ List<Particle> ActiveItem::pullNewParticles() {
       particle.velocity[0] *= -1;
       particle.flip = !particle.flip;
     }
-    result.append(move(particle));
+    result.append(std::move(particle));
   }
   result.appendAll(m_scriptedAnimator.pullNewParticles());
   return result;
@@ -462,20 +462,20 @@ LuaCallbacks ActiveItem::makeActiveItemCallbacks() {
     });
 
   callbacks.registerCallback("setCursor", [this](Maybe<String> cursor) {
-      m_cursor = move(cursor);
+      m_cursor = std::move(cursor);
     });
 
   callbacks.registerCallback("setScriptedAnimationParameter", [this](String name, Json value) {
-      m_scriptedAnimationParameters.set(move(name), move(value));
+      m_scriptedAnimationParameters.set(std::move(name), std::move(value));
     });
 
   callbacks.registerCallback("setInventoryIcon", [this](String image) {
       setInstanceValue("inventoryIcon", image);
-      setIconDrawables({Drawable::makeImage(move(image), 1.0f, true, Vec2F())});
+      setIconDrawables({Drawable::makeImage(std::move(image), 1.0f, true, Vec2F())});
     });
 
   callbacks.registerCallback("setInstanceValue", [this](String name, Json val) {
-      setInstanceValue(move(name), move(val));
+      setInstanceValue(std::move(name), std::move(val));
     });
 
   callbacks.registerCallback("callOtherHandScript", [this](String const& func, LuaVariadic<LuaValue> const& args) {
diff --git a/source/game/items/StarArmors.cpp b/source/game/items/StarArmors.cpp
index 0f8ceb4..85580d9 100644
--- a/source/game/items/StarArmors.cpp
+++ b/source/game/items/StarArmors.cpp
@@ -74,7 +74,7 @@ void ArmorItem::refreshIconDrawables() {
       drawable.imagePart().addDirectives(m_directives, true);
     }
   }
-  setIconDrawables(move(drawables));
+  setIconDrawables(std::move(drawables));
 }
 
 void ArmorItem::refreshStatusEffects() {
diff --git a/source/game/items/StarInspectionTool.cpp b/source/game/items/StarInspectionTool.cpp
index 4f9b2cf..a9b12c4 100644
--- a/source/game/items/StarInspectionTool.cpp
+++ b/source/game/items/StarInspectionTool.cpp
@@ -60,7 +60,7 @@ List<LightSource> InspectionTool::lightSources() const {
   lightSource.pointBeam = m_beamWidth;
   lightSource.beamAngle = angle;
   lightSource.beamAmbience = m_ambientFactor;
-  return {move(lightSource)};
+  return {std::move(lightSource)};
 }
 
 float InspectionTool::inspectionHighlightLevel(InspectableEntityPtr const& inspectable) const {
diff --git a/source/game/items/StarMaterialItem.cpp b/source/game/items/StarMaterialItem.cpp
index c6d2ce9..c533add 100644
--- a/source/game/items/StarMaterialItem.cpp
+++ b/source/game/items/StarMaterialItem.cpp
@@ -32,7 +32,7 @@ MaterialItem::MaterialItem(Json const& config, String const& directory, Json con
         d.imagePart().addDirectives(image, false);
       }
     }
-    setIconDrawables(move(drawables));
+    setIconDrawables(std::move(drawables));
   }
 
   setTwoHanded(config.getBool("twoHanded", true));
@@ -48,10 +48,10 @@ MaterialItem::MaterialItem(Json const& config, String const& directory, Json con
   if (m_placeSounds.empty()) {
     auto miningSound = materialDatabase->miningSound(m_material);
     if (!miningSound.empty())
-      m_placeSounds.append(move(miningSound));
+      m_placeSounds.append(std::move(miningSound));
     auto stepSound = materialDatabase->footstepSound(m_material);
     if (!stepSound.empty())
-      m_placeSounds.append(move(stepSound));
+      m_placeSounds.append(std::move(stepSound));
     else if (m_placeSounds.empty())
       m_placeSounds.append(materialDatabase->defaultFootstepSound());
   }
@@ -259,7 +259,7 @@ List<Drawable> const& MaterialItem::generatedPreview(Vec2I position) const {
           drawable.translate(-boundBox.center());
       }
 
-      m_generatedPreviewCache.emplace(move(drawables));
+      m_generatedPreviewCache.emplace(std::move(drawables));
     }
     else
       m_generatedPreviewCache.emplace(iconDrawables());
diff --git a/source/game/items/StarTools.cpp b/source/game/items/StarTools.cpp
index 7faaeae..e1bb576 100644
--- a/source/game/items/StarTools.cpp
+++ b/source/game/items/StarTools.cpp
@@ -245,7 +245,7 @@ List<LightSource> Flashlight::lightSources() const {
   lightSource.pointBeam = m_beamWidth;
   lightSource.beamAngle = angle;
   lightSource.beamAmbience = m_ambientFactor;
-  return {move(lightSource)};
+  return {std::move(lightSource)};
 }
 
 WireTool::WireTool(Json const& config, String const& directory, Json const& parameters)
diff --git a/source/game/objects/StarContainerObject.cpp b/source/game/objects/StarContainerObject.cpp
index f666902..8a3d0f4 100644
--- a/source/game/objects/StarContainerObject.cpp
+++ b/source/game/objects/StarContainerObject.cpp
@@ -119,7 +119,7 @@ void ContainerObject::render(RenderCallback* renderCallback) {
           auto audio = make_shared<AudioInstance>(*assets->audio(Random::randValueFrom(configValue("openSounds").toArray()).toString()));
           audio->setPosition(position());
           audio->setRangeMultiplier(config()->soundEffectRangeMultiplier);
-          renderCallback->addAudio(move(audio));
+          renderCallback->addAudio(std::move(audio));
         }
       }
       if (m_currentState == configValue("openFrameIndex", 2).toInt()) {
@@ -128,7 +128,7 @@ void ContainerObject::render(RenderCallback* renderCallback) {
           auto audio = make_shared<AudioInstance>(*assets->audio(Random::randValueFrom(configValue("closeSounds").toArray()).toString()));
           audio->setPosition(position());
           audio->setRangeMultiplier(config()->soundEffectRangeMultiplier);
-          renderCallback->addAudio(move(audio));
+          renderCallback->addAudio(std::move(audio));
         }
       }
       if (m_opened.get() < m_currentState) {
diff --git a/source/game/objects/StarLoungeableObject.cpp b/source/game/objects/StarLoungeableObject.cpp
index 7a3fbea..a84a6dc 100644
--- a/source/game/objects/StarLoungeableObject.cpp
+++ b/source/game/objects/StarLoungeableObject.cpp
@@ -19,7 +19,7 @@ void LoungeableObject::render(RenderCallback* renderCallback) {
             Drawable::makeImage(m_sitCoverImage, 1.0f / TilePixels, false, position() + orientation->imagePosition);
         if (m_flipImages)
           drawable.scale(Vec2F(-1, 1), drawable.boundBox(false).center());
-        renderCallback->addDrawable(move(drawable), RenderLayerObject + 2);
+        renderCallback->addDrawable(std::move(drawable), RenderLayerObject + 2);
       }
     }
   }
diff --git a/source/game/objects/StarPhysicsObject.cpp b/source/game/objects/StarPhysicsObject.cpp
index f327473..9da604d 100644
--- a/source/game/objects/StarPhysicsObject.cpp
+++ b/source/game/objects/StarPhysicsObject.cpp
@@ -7,7 +7,7 @@
 
 namespace Star {
 
-PhysicsObject::PhysicsObject(ObjectConfigConstPtr config, Json const& parameters) : Object(move(config), parameters) {
+PhysicsObject::PhysicsObject(ObjectConfigConstPtr config, Json const& parameters) : Object(std::move(config), parameters) {
   for (auto const& p : configValue("physicsForces", JsonObject()).iterateObject()) {
     auto& forceConfig = m_physicsForces[p.first];
 
@@ -60,7 +60,7 @@ void PhysicsObject::init(World* world, EntityId entityId, EntityMode mode) {
         auto& collisionConfig = m_physicsCollisions.get(collision);
         collisionConfig.enabled.set(enabled);
       });
-    m_scriptComponent.addCallbacks("physics", move(physicsCallbacks));
+    m_scriptComponent.addCallbacks("physics", std::move(physicsCallbacks));
   }
   Object::init(world, entityId, mode);
   m_metaBoundBox = Object::metaBoundBox();
@@ -92,7 +92,7 @@ List<PhysicsForceRegion> PhysicsObject::forceRegions() const {
     if (p.second.enabled.get()) {
       PhysicsForceRegion forceRegion = p.second.forceRegion;
       forceRegion.call([pos = position()](auto& fr) { fr.translate(pos); });
-      forces.append(move(forceRegion));
+      forces.append(std::move(forceRegion));
     }
   }
   return forces;
diff --git a/source/game/scripting/StarInputLuaBindings.cpp b/source/game/scripting/StarInputLuaBindings.cpp
index 1af5a74..9a99c4a 100644
--- a/source/game/scripting/StarInputLuaBindings.cpp
+++ b/source/game/scripting/StarInputLuaBindings.cpp
@@ -49,7 +49,7 @@ LuaCallbacks LuaBindings::makeInputCallbacks() {
         result.emplace_back(jEvent.set("processed", pair.second));
     }
 
-    return move(result);
+    return result;
   });
 
   callbacks.registerCallbackWithSignature<Vec2I>("mousePosition", bind(mem_fn(&Input::mousePosition), input));
diff --git a/source/game/scripting/StarLuaActorMovementComponent.hpp b/source/game/scripting/StarLuaActorMovementComponent.hpp
index 6dc0fc6..5744da8 100644
--- a/source/game/scripting/StarLuaActorMovementComponent.hpp
+++ b/source/game/scripting/StarLuaActorMovementComponent.hpp
@@ -369,7 +369,7 @@ Maybe<Ret> LuaActorMovementComponent<Base>::update(V&&... args) {
     if (m_autoClearControls)
       clearControls();
   }
-  Maybe<Ret> ret = Base::template update<Ret>(forward<V>(args)...);
+  Maybe<Ret> ret = Base::template update<Ret>(std::forward<V>(args)...);
   performControls();
   return ret;
 }
diff --git a/source/game/scripting/StarLuaAnimationComponent.hpp b/source/game/scripting/StarLuaAnimationComponent.hpp
index 0cbd280..21742fb 100644
--- a/source/game/scripting/StarLuaAnimationComponent.hpp
+++ b/source/game/scripting/StarLuaAnimationComponent.hpp
@@ -69,7 +69,7 @@ LuaAnimationComponent<Base>::LuaAnimationComponent() {
       if (auto image = drawable.part.ptr<Drawable::ImagePart>())
         image->transformation.scale(0.125f);
 
-      m_drawables.append({move(drawable), renderLayer});
+      m_drawables.append({std::move(drawable), renderLayer});
     });
   animationCallbacks.registerCallback("clearLightSources", [this]() {
       m_lightSources.clear();
@@ -84,7 +84,7 @@ LuaAnimationComponent<Base>::LuaAnimationComponent() {
           lightSourceTable.get<Maybe<float>>("beamAmbience").value()
         });
     });
-  Base::addCallbacks("localAnimator", move(animationCallbacks));
+  Base::addCallbacks("localAnimator", std::move(animationCallbacks));
 }
 
 template <typename Base>
diff --git a/source/game/scripting/StarLuaComponents.cpp b/source/game/scripting/StarLuaComponents.cpp
index 2d7c819..9a1b1c4 100644
--- a/source/game/scripting/StarLuaComponents.cpp
+++ b/source/game/scripting/StarLuaComponents.cpp
@@ -17,14 +17,14 @@ StringList const& LuaBaseComponent::scripts() const {
 }
 
 void LuaBaseComponent::setScript(String script) {
-  setScripts({move(script)});
+  setScripts({std::move(script)});
 }
 
 void LuaBaseComponent::setScripts(StringList scripts) {
   if (initialized())
     throw LuaComponentException("Cannot call LuaWorldComponent::setScripts when LuaWorldComponent is initialized");
 
-  m_scripts = move(scripts);
+  m_scripts = std::move(scripts);
 }
 
 void LuaBaseComponent::addCallbacks(String groupName, LuaCallbacks callbacks) {
@@ -58,7 +58,7 @@ void LuaBaseComponent::setAutoReInit(bool autoReInit) {
 }
 
 void LuaBaseComponent::setLuaRoot(LuaRootPtr luaRoot) {
-  m_luaRoot = move(luaRoot);
+  m_luaRoot = std::move(luaRoot);
 }
 
 LuaRootPtr const& LuaBaseComponent::luaRoot() {
@@ -140,7 +140,7 @@ void LuaBaseComponent::contextShutdown() {}
 
 void LuaBaseComponent::setError(String error) {
   m_context.reset();
-  m_error = move(error);
+  m_error = std::move(error);
 }
 
 bool LuaBaseComponent::checkInitialization() {
diff --git a/source/game/scripting/StarLuaComponents.hpp b/source/game/scripting/StarLuaComponents.hpp
index e739912..98e3638 100644
--- a/source/game/scripting/StarLuaComponents.hpp
+++ b/source/game/scripting/StarLuaComponents.hpp
@@ -191,7 +191,7 @@ Maybe<Ret> LuaBaseComponent::invoke(String const& name, V&&... args) {
     auto method = m_context->getPath(name);
     if (method == LuaNil)
       return {};
-    return m_context->luaTo<LuaFunction>(move(method)).invoke<Ret>(forward<V>(args)...);
+    return m_context->luaTo<LuaFunction>(std::move(method)).invoke<Ret>(std::forward<V>(args)...);
   } catch (LuaException const& e) {
     Logger::error("Exception while invoking lua function '{}'. {}", name, outputException(e, true));
     setError(printException(e, false));
@@ -223,15 +223,15 @@ JsonObject LuaStorableComponent<Base>::getScriptStorage() const {
 template <typename Base>
 void LuaStorableComponent<Base>::setScriptStorage(JsonObject storage) {
   if (Base::initialized())
-    Base::context()->setPath("storage", move(storage));
+    Base::context()->setPath("storage", std::move(storage));
   else
-    m_storage = move(storage);
+    m_storage = std::move(storage);
 }
 
 template <typename Base>
 void LuaStorableComponent<Base>::contextSetup() {
   Base::contextSetup();
-  Base::context()->setPath("storage", move(m_storage));
+  Base::context()->setPath("storage", std::move(m_storage));
 }
 
 template <typename Base>
@@ -253,7 +253,7 @@ LuaUpdatableComponent<Base>::LuaUpdatableComponent() {
     });
 
   m_lastDt = GlobalTimestep * GlobalTimescale;
-  Base::addCallbacks("script", move(scriptCallbacks));
+  Base::addCallbacks("script", std::move(scriptCallbacks));
 }
 
 template <typename Base>
@@ -289,7 +289,7 @@ Maybe<Ret> LuaUpdatableComponent<Base>::update(V&&... args) {
   if (!m_updatePeriodic.tick())
     return {};
 
-  return Base::template invoke<Ret>("update", forward<V>(args)...);
+  return Base::template invoke<Ret>("update", std::forward<V>(args)...);
 }
 
 template <typename Base>
@@ -332,7 +332,7 @@ LuaMessageHandlingComponent<Base>::LuaMessageHandlingComponent() {
         m_messageHandlers.remove(handlerInfo.name);
     });
 
-  Base::addCallbacks("message", move(scriptCallbacks));
+  Base::addCallbacks("message", std::move(scriptCallbacks));
 }
 
 template <typename Base>
diff --git a/source/game/scripting/StarLuaGameConverters.cpp b/source/game/scripting/StarLuaGameConverters.cpp
index e5f8811..64415e6 100644
--- a/source/game/scripting/StarLuaGameConverters.cpp
+++ b/source/game/scripting/StarLuaGameConverters.cpp
@@ -65,7 +65,7 @@ Maybe<CollisionSet> LuaConverter<CollisionSet>::to(LuaEngine& engine, LuaValue c
   CollisionSet result;
   bool failed = false;
   table->iterate([&result, &failed, &engine](LuaValue, LuaValue value) {
-      if (auto k = engine.luaMaybeTo<CollisionKind>(move(value))) {
+      if (auto k = engine.luaMaybeTo<CollisionKind>(std::move(value))) {
         result.insert(*k);
         return true;
       } else {
@@ -96,7 +96,7 @@ LuaValue LuaConverter<PlatformerAStar::Path>::from(LuaEngine& engine, Platformer
     edgeTable.set("jumpVelocity", edge.jumpVelocity);
     edgeTable.set("source", convertNode(edge.source));
     edgeTable.set("target", convertNode(edge.target));
-    pathTable.set(pathTableIndex++, move(edgeTable));
+    pathTable.set(pathTableIndex++, std::move(edgeTable));
   }
   return pathTable;
 }
@@ -328,7 +328,7 @@ LuaValue LuaConverter<StatModifier>::from(LuaEngine& engine, StatModifier const&
 }
 
 Maybe<StatModifier> LuaConverter<StatModifier>::to(LuaEngine& engine, LuaValue v) {
-  auto json = engine.luaMaybeTo<Json>(move(v));
+  auto json = engine.luaMaybeTo<Json>(std::move(v));
   if (!json)
     return {};
 
diff --git a/source/game/scripting/StarUniverseServerLuaBindings.cpp b/source/game/scripting/StarUniverseServerLuaBindings.cpp
index f6f5cd7..4a6649b 100644
--- a/source/game/scripting/StarUniverseServerLuaBindings.cpp
+++ b/source/game/scripting/StarUniverseServerLuaBindings.cpp
@@ -123,7 +123,7 @@ StringList LuaBindings::UniverseServerCallbacks::activeWorlds(UniverseServer* un
 }
 
 RpcThreadPromise<Json> LuaBindings::UniverseServerCallbacks::sendWorldMessage(UniverseServer* universe, String const& worldId, String const& message, LuaVariadic<Json> args) {
-  return universe->sendWorldMessage(parseWorldId(worldId), message, JsonArray::from(move(args)));
+  return universe->sendWorldMessage(parseWorldId(worldId), message, JsonArray::from(std::move(args)));
 }
 
 }
diff --git a/source/game/scripting/StarWorldLuaBindings.cpp b/source/game/scripting/StarWorldLuaBindings.cpp
index 1a21bad..7d74a98 100644
--- a/source/game/scripting/StarWorldLuaBindings.cpp
+++ b/source/game/scripting/StarWorldLuaBindings.cpp
@@ -449,7 +449,7 @@ namespace LuaBindings {
           auto distributions = distributionConfigs.transformed([](Json const& config) {
             return BiomeItemDistribution(config, Random::randu64());
           });
-          return serverWorld->enqueuePlacement(move(distributions), id);
+          return serverWorld->enqueuePlacement(std::move(distributions), id);
         });
     }
 
@@ -1069,7 +1069,7 @@ namespace LuaBindings {
       Vec2F const& end,
       ActorMovementParameters actorMovementParameters,
       PlatformerAStar::Parameters searchParameters) {
-    PlatformerAStar::PathFinder pathFinder(world, start, end, move(actorMovementParameters), move(searchParameters));
+    PlatformerAStar::PathFinder pathFinder(world, start, end, std::move(actorMovementParameters), std::move(searchParameters));
     pathFinder.explore({});
     return pathFinder.result();
   }
@@ -1079,7 +1079,7 @@ namespace LuaBindings {
       Vec2F const& end,
       ActorMovementParameters actorMovementParameters,
       PlatformerAStar::Parameters searchParameters) {
-    return PlatformerAStar::PathFinder(world, start, end, move(actorMovementParameters), move(searchParameters));
+    return PlatformerAStar::PathFinder(world, start, end, std::move(actorMovementParameters), std::move(searchParameters));
   }
 
   RectI ClientWorldCallbacks::clientWindow(WorldClient* world) {
@@ -1205,15 +1205,15 @@ namespace LuaBindings {
   }
 
   LuaTable WorldEntityCallbacks::entityQuery(World* world, LuaEngine& engine, Vec2F const& pos1, LuaValue const& pos2, Maybe<LuaTable> options) {
-    return LuaBindings::entityQuery<Entity>(world, engine, pos1, pos2, move(options));
+    return LuaBindings::entityQuery<Entity>(world, engine, pos1, pos2, std::move(options));
   }
 
   LuaTable WorldEntityCallbacks::monsterQuery(World* world, LuaEngine& engine, Vec2F const& pos1, LuaValue const& pos2, Maybe<LuaTable> options) {
-    return LuaBindings::entityQuery<Monster>(world, engine, pos1, pos2, move(options));
+    return LuaBindings::entityQuery<Monster>(world, engine, pos1, pos2, std::move(options));
   }
 
   LuaTable WorldEntityCallbacks::npcQuery(World* world, LuaEngine& engine, Vec2F const& pos1, LuaValue const& pos2, Maybe<LuaTable> options) {
-    return LuaBindings::entityQuery<Npc>(world, engine, pos1, pos2, move(options));
+    return LuaBindings::entityQuery<Npc>(world, engine, pos1, pos2, std::move(options));
   }
 
   LuaTable WorldEntityCallbacks::objectQuery(World* world, LuaEngine& engine, Vec2F const& pos1, LuaValue const& pos2, Maybe<LuaTable> options) {
@@ -1225,18 +1225,18 @@ namespace LuaBindings {
         engine,
         pos1,
         pos2,
-        move(options),
+        std::move(options),
         [&objectName](shared_ptr<Object> const& entity) -> bool {
           return objectName.empty() || entity->name() == objectName;
         });
   }
 
   LuaTable WorldEntityCallbacks::itemDropQuery(World* world, LuaEngine& engine, Vec2F const& pos1, LuaValue const& pos2, Maybe<LuaTable> options) {
-    return LuaBindings::entityQuery<ItemDrop>(world, engine, pos1, pos2, move(options));
+    return LuaBindings::entityQuery<ItemDrop>(world, engine, pos1, pos2, std::move(options));
   }
 
   LuaTable WorldEntityCallbacks::playerQuery(World* world, LuaEngine& engine, Vec2F const& pos1, LuaValue const& pos2, Maybe<LuaTable> options) {
-    return LuaBindings::entityQuery<Player>(world, engine, pos1, pos2, move(options));
+    return LuaBindings::entityQuery<Player>(world, engine, pos1, pos2, std::move(options));
   }
 
   LuaTable WorldEntityCallbacks::loungeableQuery(World* world, LuaEngine& engine, Vec2F const& pos1, LuaValue const& pos2, Maybe<LuaTable> options) {
@@ -1267,19 +1267,19 @@ namespace LuaBindings {
       return pos && pos->orientation == orientation;
     };
 
-    return LuaBindings::entityQuery<LoungeableObject>(world, engine, pos1, pos2, move(options), filter);
+    return LuaBindings::entityQuery<LoungeableObject>(world, engine, pos1, pos2, std::move(options), filter);
   }
 
   LuaTable WorldEntityCallbacks::entityLineQuery(World* world, LuaEngine& engine, Vec2F const& point1, Vec2F const& point2, Maybe<LuaTable> options) {
-    return LuaBindings::entityLineQuery<Entity>(world, engine, point1, point2, move(options));
+    return LuaBindings::entityLineQuery<Entity>(world, engine, point1, point2, std::move(options));
   }
 
   LuaTable WorldEntityCallbacks::objectLineQuery(World* world, LuaEngine& engine, Vec2F const& point1, Vec2F const& point2, Maybe<LuaTable> options) {
-    return LuaBindings::entityLineQuery<Object>(world, engine, point1, point2, move(options));
+    return LuaBindings::entityLineQuery<Object>(world, engine, point1, point2, std::move(options));
   }
 
   LuaTable WorldEntityCallbacks::npcLineQuery(World* world, LuaEngine& engine, Vec2F const& point1, Vec2F const& point2, Maybe<LuaTable> options) {
-    return LuaBindings::entityLineQuery<Npc>(world, engine, point1, point2, move(options));
+    return LuaBindings::entityLineQuery<Npc>(world, engine, point1, point2, std::move(options));
   }
 
   bool WorldEntityCallbacks::entityExists(World* world, EntityId entityId) {
@@ -1744,9 +1744,9 @@ namespace LuaBindings {
 
   RpcPromise<Json> WorldEntityCallbacks::sendEntityMessage(World* world, LuaEngine& engine, LuaValue entityId, String const& message, LuaVariadic<Json> args) {
     if (entityId.is<LuaString>())
-      return world->sendEntityMessage(engine.luaTo<String>(entityId), message, JsonArray::from(move(args)));
+      return world->sendEntityMessage(engine.luaTo<String>(entityId), message, JsonArray::from(std::move(args)));
     else
-      return world->sendEntityMessage(engine.luaTo<EntityId>(entityId), message, JsonArray::from(move(args)));
+      return world->sendEntityMessage(engine.luaTo<EntityId>(entityId), message, JsonArray::from(std::move(args)));
   }
 
   Maybe<bool> WorldEntityCallbacks::loungeableOccupied(World* world, EntityId entityId) {
diff --git a/source/rendering/StarAssetTextureGroup.cpp b/source/rendering/StarAssetTextureGroup.cpp
index afffab7..c377a07 100644
--- a/source/rendering/StarAssetTextureGroup.cpp
+++ b/source/rendering/StarAssetTextureGroup.cpp
@@ -8,7 +8,7 @@
 namespace Star {
 
 AssetTextureGroup::AssetTextureGroup(TextureGroupPtr textureGroup)
-  : m_textureGroup(move(textureGroup)) {
+  : m_textureGroup(std::move(textureGroup)) {
   m_reloadTracker = make_shared<TrackerListener>();
   Root::singleton().registerReloadListener(m_reloadTracker);
 }
diff --git a/source/rendering/StarDrawablePainter.cpp b/source/rendering/StarDrawablePainter.cpp
index 0ef1f31..5f9fd79 100644
--- a/source/rendering/StarDrawablePainter.cpp
+++ b/source/rendering/StarDrawablePainter.cpp
@@ -3,8 +3,8 @@
 namespace Star {
 
 DrawablePainter::DrawablePainter(RendererPtr renderer, AssetTextureGroupPtr textureGroup) {
-  m_renderer = move(renderer);
-  m_textureGroup = move(textureGroup);
+  m_renderer = std::move(renderer);
+  m_textureGroup = std::move(textureGroup);
 }
 
 void DrawablePainter::drawDrawable(Drawable const& drawable) {
@@ -48,7 +48,7 @@ void DrawablePainter::drawDrawable(Drawable const& drawable) {
 
     float param1 = drawable.fullbright ? 0.0f : 1.0f;
 
-    primitives.emplace_back(std::in_place_type_t<RenderQuad>(), move(texture),
+    primitives.emplace_back(std::in_place_type_t<RenderQuad>(), std::move(texture),
         lowerLeft,  Vec2F{0, 0},
         lowerRight, Vec2F{textureSize[0], 0},
         upperRight, Vec2F{textureSize[0], textureSize[1]},
diff --git a/source/rendering/StarEnvironmentPainter.cpp b/source/rendering/StarEnvironmentPainter.cpp
index c938ae0..7501f77 100644
--- a/source/rendering/StarEnvironmentPainter.cpp
+++ b/source/rendering/StarEnvironmentPainter.cpp
@@ -26,7 +26,7 @@ float const EnvironmentPainter::RayMinUnscaledAlpha = 1;
 Vec3B const EnvironmentPainter::RayColor = Vec3B(255, 255, 200);
 
 EnvironmentPainter::EnvironmentPainter(RendererPtr renderer) {
-  m_renderer = move(renderer);
+  m_renderer = std::move(renderer);
   m_textureGroup = make_shared<AssetTextureGroup>(m_renderer->createTextureGroup(TextureGroupSize::Large));
   m_timer = 0;
   m_rayPerlin = PerlinF(1, RayPerlinFrequency, RayPerlinAmplitude, 0, 2.0f, 2.0f, Random::randu64());
@@ -189,13 +189,13 @@ void EnvironmentPainter::renderPlanetHorizon(float pixelRatio, Vec2F const& scre
     PolyF rightImage = PolyF(rightRect);
     rightImage.rotate(planetHorizon.rotation, center);
 
-    primitives.emplace_back(std::in_place_type_t<RenderQuad>(), move(leftTexture),
+    primitives.emplace_back(std::in_place_type_t<RenderQuad>(), std::move(leftTexture),
         leftImage[0], Vec2F(0, 0),
         leftImage[1], Vec2F(leftTextureSize[0], 0),
         leftImage[2], Vec2F(leftTextureSize[0], leftTextureSize[1]),
         leftImage[3], Vec2F(0, leftTextureSize[1]), Vec4B::filled(255), 0.0f);
 
-    primitives.emplace_back(std::in_place_type_t<RenderQuad>(), move(rightTexture),
+    primitives.emplace_back(std::in_place_type_t<RenderQuad>(), std::move(rightTexture),
         rightImage[0], Vec2F(0, 0),
         rightImage[1], Vec2F(rightTextureSize[0], 0),
         rightImage[2], Vec2F(rightTextureSize[0], rightTextureSize[1]),
@@ -322,7 +322,7 @@ void EnvironmentPainter::renderParallaxLayers(
           withDirectives.directives += layer.directives;
           if (auto texture = m_textureGroup->tryTexture(withDirectives)) {
             RectF drawRect = RectF::withSize(anchorPoint, subImage.size() * camera.pixelRatio());
-            primitives.emplace_back(std::in_place_type_t<RenderQuad>(), move(texture),
+            primitives.emplace_back(std::in_place_type_t<RenderQuad>(), std::move(texture),
                 RenderVertex{drawRect.min(), subImage.min(), drawColor, lightMapMultiplier},
                 RenderVertex{{drawRect.xMax(), drawRect.yMin()}, {subImage.xMax(), subImage.yMin()}, drawColor, lightMapMultiplier},
                 RenderVertex{drawRect.max(), subImage.max(), drawColor, lightMapMultiplier},
@@ -426,7 +426,7 @@ void EnvironmentPainter::drawOrbiter(float pixelRatio, Vec2F const& screenSize,
   RectF renderRect = RectF::withCenter(position, texSize * orbiter.scale * pixelRatio);
   Vec4B renderColor = Vec4B(255, 255, 255, 255 * alpha);
 
-  m_renderer->immediatePrimitives().emplace_back(std::in_place_type_t<RenderQuad>(), move(texture),
+  m_renderer->immediatePrimitives().emplace_back(std::in_place_type_t<RenderQuad>(), std::move(texture),
       renderMatrix.transformVec2(renderRect.min()), Vec2F(0, 0),
       renderMatrix.transformVec2(Vec2F{renderRect.xMax(), renderRect.yMin()}), Vec2F(texSize[0], 0),
       renderMatrix.transformVec2(renderRect.max()), Vec2F(texSize[0], texSize[1]),
diff --git a/source/rendering/StarFontTextureGroup.cpp b/source/rendering/StarFontTextureGroup.cpp
index a951358..d5ad88d 100644
--- a/source/rendering/StarFontTextureGroup.cpp
+++ b/source/rendering/StarFontTextureGroup.cpp
@@ -5,7 +5,7 @@
 namespace Star {
 
 FontTextureGroup::FontTextureGroup(TextureGroupPtr textureGroup)
-  : m_textureGroup(move(textureGroup)) {}
+  : m_textureGroup(std::move(textureGroup)) {}
 
 void FontTextureGroup::cleanup(int64_t timeout) {
   int64_t currentTime = Time::monotonicMilliseconds();
diff --git a/source/rendering/StarTextPainter.cpp b/source/rendering/StarTextPainter.cpp
index 748aa52..fe352d1 100644
--- a/source/rendering/StarTextPainter.cpp
+++ b/source/rendering/StarTextPainter.cpp
@@ -279,7 +279,7 @@ StringList TextPainter::wrapText(StringView s, Maybe<unsigned> wrapWidth) {
   int lastLine = 0;
   TextPainter::WrapTextCallback textCallback = [&](StringView text, int line) {
     if (lastLine != line) {
-      result.append(move(current));
+      result.append(std::move(current));
       lastLine = line;
     }
 
@@ -290,7 +290,7 @@ StringList TextPainter::wrapText(StringView s, Maybe<unsigned> wrapWidth) {
   processWrapText(s, wrapWidth.ptr(), textCallback);
 
   if (!current.empty())
-    result.append(move(current));
+    result.append(std::move(current));
 
   return result;
 };
@@ -312,7 +312,7 @@ void TextPainter::setMode(FontMode mode) {
 }
 
 void TextPainter::setFontColor(Vec4B color) {
-  m_renderSettings.color = move(color);
+  m_renderSettings.color = std::move(color);
 }
 
 void TextPainter::setProcessingDirectives(StringView directives) {
@@ -411,7 +411,7 @@ RectF TextPainter::doRenderText(StringView s, TextPositioning const& position, b
       break;
   }
 
-  m_renderSettings = move(backupRenderSettings);
+  m_renderSettings = std::move(backupRenderSettings);
 
   return bounds;
 }
diff --git a/source/rendering/StarTilePainter.cpp b/source/rendering/StarTilePainter.cpp
index 5655930..31fe0a6 100644
--- a/source/rendering/StarTilePainter.cpp
+++ b/source/rendering/StarTilePainter.cpp
@@ -11,7 +11,7 @@
 namespace Star {
 
 TilePainter::TilePainter(RendererPtr renderer) : TileDrawer() {
-  m_renderer = move(renderer);
+  m_renderer = std::move(renderer);
   m_textureGroup = m_renderer->createTextureGroup(TextureGroupSize::Large);
 
   auto& root = Root::singleton();
@@ -190,7 +190,7 @@ shared_ptr<TilePainter::TerrainChunk const> TilePainter::getTerrainChunk(WorldRe
         for (auto& zLevelPair : layerPair.second) {
           auto rb = m_renderer->createRenderBuffer();
           rb->set(zLevelPair.second);
-          (*chunk)[layerPair.first][zLevelPair.first] = move(rb);
+          (*chunk)[layerPair.first][zLevelPair.first] = std::move(rb);
         }
       }
 
@@ -214,7 +214,7 @@ shared_ptr<TilePainter::LiquidChunk const> TilePainter::getLiquidChunk(WorldRend
       for (auto& p : liquidPrimitives) {
         auto rb = m_renderer->createRenderBuffer();
         rb->set(p.second);
-        chunk->set(p.first, move(rb));
+        chunk->set(p.first, std::move(rb));
       }
 
       return chunk;
@@ -296,7 +296,7 @@ bool TilePainter::produceTerrainPrimitives(HashMap<QuadZLevel, List<RenderPrimit
       if (!variant) continue;
       RectF textureCoords = variant->wrap(variance);
       RectF worldCoords = RectF::withSize(piecePair.second / TilePixels + Vec2F(pos), textureCoords.size() / TilePixels);
-      quadList.emplace_back(std::in_place_type_t<RenderQuad>(), move(texture),
+      quadList.emplace_back(std::in_place_type_t<RenderQuad>(), std::move(texture),
           worldCoords  .min(),
           textureCoords.min(),
           Vec2F(  worldCoords.xMax(),   worldCoords.yMin()),
@@ -323,7 +323,7 @@ bool TilePainter::produceTerrainPrimitives(HashMap<QuadZLevel, List<RenderPrimit
       if (!variant) continue;
       auto& textureCoords = variant->wrap(variance);
       RectF worldCoords = RectF::withSize(piecePair.second / TilePixels + Vec2F(pos), textureCoords.size() / TilePixels);
-      quadList.emplace_back(std::in_place_type_t<RenderQuad>(), move(texture),
+      quadList.emplace_back(std::in_place_type_t<RenderQuad>(), std::move(texture),
           worldCoords.min(), textureCoords.min(),
           Vec2F(worldCoords.xMax(), worldCoords.yMin()), Vec2F(textureCoords.xMax(), textureCoords.yMin()),
           worldCoords.max(), textureCoords.max(),
@@ -343,7 +343,7 @@ bool TilePainter::produceTerrainPrimitives(HashMap<QuadZLevel, List<RenderPrimit
     RectF textureCoords = RectF::withSize(Vec2F(), textureSize);
     RectF worldCoords = RectF::withSize(crackingImage.second / TilePixels + Vec2F(pos), textureCoords.size() / TilePixels);
 
-    quadList.emplace_back(std::in_place_type_t<RenderQuad>(), move(texture),
+    quadList.emplace_back(std::in_place_type_t<RenderQuad>(), std::move(texture),
         worldCoords.min(), textureCoords.min(),
         Vec2F(worldCoords.xMax(), worldCoords.yMin()), Vec2F(textureCoords.xMax(), textureCoords.yMin()),
         worldCoords.max(), textureCoords.max(),
diff --git a/source/rendering/StarWorldCamera.hpp b/source/rendering/StarWorldCamera.hpp
index d85543a..8ef39cb 100644
--- a/source/rendering/StarWorldCamera.hpp
+++ b/source/rendering/StarWorldCamera.hpp
@@ -75,7 +75,7 @@ inline float WorldCamera::pixelRatio() const {
 }
 
 inline void WorldCamera::setWorldGeometry(WorldGeometry geometry) {
-  m_worldGeometry = move(geometry);
+  m_worldGeometry = std::move(geometry);
 }
 
 inline WorldGeometry WorldCamera::worldGeometry() const {
diff --git a/source/rendering/StarWorldPainter.cpp b/source/rendering/StarWorldPainter.cpp
index d89cfe1..e106307 100644
--- a/source/rendering/StarWorldPainter.cpp
+++ b/source/rendering/StarWorldPainter.cpp
@@ -28,7 +28,7 @@ WorldPainter::WorldPainter() {
 void WorldPainter::renderInit(RendererPtr renderer) {
   m_assets = Root::singleton().assets();
 
-  m_renderer = move(renderer);
+  m_renderer = std::move(renderer);
   auto textureGroup = m_renderer->createTextureGroup(TextureGroupSize::Large);
   m_textPainter = make_shared<TextPainter>(m_renderer, textureGroup);
   m_tilePainter = make_shared<TilePainter>(m_renderer);
@@ -110,7 +110,7 @@ void WorldPainter::render(WorldRenderData& renderData, function<void()> lightWai
   Map<EntityRenderLayer, List<pair<EntityHighlightEffect, List<Drawable>>>> entityDrawables;
   for (auto& ed : renderData.entityDrawables) {
     for (auto& p : ed.layers)
-      entityDrawables[p.first].append({ed.highlightEffect, move(p.second)});
+      entityDrawables[p.first].append({ed.highlightEffect, std::move(p.second)});
   }
 
   auto entityDrawableIterator = entityDrawables.begin();
@@ -121,7 +121,7 @@ void WorldPainter::render(WorldRenderData& renderData, function<void()> lightWai
       if (until && entityDrawableIterator->first >= *until)
         break;
       for (auto& edl : entityDrawableIterator->second)
-        drawEntityLayer(move(edl.second), edl.first);
+        drawEntityLayer(std::move(edl.second), edl.first);
       ++entityDrawableIterator;
     }
 
@@ -221,7 +221,7 @@ void WorldPainter::renderParticles(WorldRenderData& renderData, Particle::Layer
       drawable.rotate(particle.rotation);
       drawable.scale(particle.size);
       drawable.translate(particle.position);
-      drawDrawable(move(drawable));
+      drawDrawable(std::move(drawable));
 
     } else if (particle.type == Particle::Type::Text) {
       Vec2F position = m_camera.worldToScreen(particle.position);
@@ -275,7 +275,7 @@ void WorldPainter::drawEntityLayer(List<Drawable> drawables, EntityHighlightEffe
           underlayDrawable.fullbright = true;
           underlayDrawable.color = Color::rgbaf(1, 1, 1, highlightEffect.level);
           underlayDrawable.imagePart().addDirectives(underlayDirectives, true);
-          drawDrawable(move(underlayDrawable));
+          drawDrawable(std::move(underlayDrawable));
         }
       }
     }
@@ -289,12 +289,12 @@ void WorldPainter::drawEntityLayer(List<Drawable> drawables, EntityHighlightEffe
         overlayDrawable.fullbright = true;
         overlayDrawable.color = Color::rgbaf(1, 1, 1, highlightEffect.level);
         overlayDrawable.imagePart().addDirectives(overlayDirectives, true);
-        drawDrawable(move(overlayDrawable));
+        drawDrawable(std::move(overlayDrawable));
       }
     }
   } else {
     for (auto& d : drawables)
-      drawDrawable(move(d));
+      drawDrawable(std::move(d));
   }
 }
 
@@ -316,7 +316,7 @@ void WorldPainter::drawDrawable(Drawable drawable) {
 
 void WorldPainter::drawDrawableSet(List<Drawable>& drawables) {
   for (Drawable& drawable : drawables)
-    drawDrawable(move(drawable));
+    drawDrawable(std::move(drawable));
 
   m_renderer->flush();
 }
diff --git a/source/test/StarTestUniverse.cpp b/source/test/StarTestUniverse.cpp
index a7b9dd2..fc3b75b 100644
--- a/source/test/StarTestUniverse.cpp
+++ b/source/test/StarTestUniverse.cpp
@@ -67,7 +67,7 @@ List<Drawable> TestUniverse::currentClientDrawables() {
   List<Drawable> drawables;
   for (auto& ed : renderData.entityDrawables) {
     for (auto& p : ed.layers)
-      drawables.appendAll(move(p.second));
+      drawables.appendAll(std::move(p.second));
   }
 
   return drawables;
diff --git a/source/test/btree_test.cpp b/source/test/btree_test.cpp
index 2d22631..022db51 100644
--- a/source/test/btree_test.cpp
+++ b/source/test/btree_test.cpp
@@ -220,7 +220,7 @@ Data const& SimpleBTreeLeaf<Key, Data, Pointer>::data(size_t i) const {
 
 template <typename Key, typename Data, typename Pointer>
 void SimpleBTreeLeaf<Key, Data, Pointer>::insert(size_t i, Key k, Data d) {
-  elements.insertAt(i, Element{move(k), move(d)});
+  elements.insertAt(i, Element{std::move(k), std::move(d)});
 }
 
 template <typename Key, typename Data, typename Pointer>
@@ -272,7 +272,7 @@ Maybe<Pointer> SimpleBTreeLeaf<Key, Data, Pointer>::nextLeaf() const {
 
 template <typename Key, typename Data, typename Pointer>
 void SimpleBTreeLeaf<Key, Data, Pointer>::setNextLeaf(Maybe<Pointer> n) {
-  next = move(n);
+  next = std::move(n);
 }
 
 // Testing BTree class that simulates storage by storing in-memory copies of
diff --git a/source/test/game_tests_main.cpp b/source/test/game_tests_main.cpp
index 4cfb714..44729b3 100644
--- a/source/test/game_tests_main.cpp
+++ b/source/test/game_tests_main.cpp
@@ -22,7 +22,7 @@ public:
   Root::Settings settings;
 
   TestEnvironment(Root::Settings settings)
-    : settings(move(settings)) {}
+    : settings(std::move(settings)) {}
 
   virtual void SetUp() {
     Logger::addSink(make_shared<ErrorLogSink>());
diff --git a/source/test/ref_ptr_test.cpp b/source/test/ref_ptr_test.cpp
index cc585f2..454ccd8 100644
--- a/source/test/ref_ptr_test.cpp
+++ b/source/test/ref_ptr_test.cpp
@@ -67,7 +67,7 @@ TEST(IntrusivePtr, All) {
     EXPECT_NE(p3, p5);
 
     p5 = p2;
-    p2 = move(p5);
+    p2 = std::move(p5);
     EXPECT_TRUE(is<Test2>(p2));
 
     RefPtr<Test1> p6 = as<Test1>(p1);
diff --git a/source/test/universe_connection_test.cpp b/source/test/universe_connection_test.cpp
index 649b7d2..c5ae0f6 100644
--- a/source/test/universe_connection_test.cpp
+++ b/source/test/universe_connection_test.cpp
@@ -19,7 +19,7 @@ unsigned const SyncWaitMillis = 10000;
 class ASyncClientThread : public Thread {
 public:
   ASyncClientThread(UniverseConnection conn)
-    : Thread("UniverseConnectionTestClientThread"), m_connection(move(conn)) {
+    : Thread("UniverseConnectionTestClientThread"), m_connection(std::move(conn)) {
     start();
   }
 
@@ -66,7 +66,7 @@ private:
 class SyncClientThread : public Thread {
 public:
   SyncClientThread(UniverseConnection conn)
-    : Thread("UniverseConnectionTestClientThread"), m_connection(move(conn)) {
+    : Thread("UniverseConnectionTestClientThread"), m_connection(std::move(conn)) {
     start();
   }
 
@@ -104,36 +104,36 @@ TEST(UniverseConnections, All) {
   TcpServer tcpServer(HostAddressWithPort(HostAddress::localhost(), ServerPort));
   tcpServer.setAcceptCallback([&server, &clientId](TcpSocketPtr socket) {
       socket->setNonBlocking(true);
-      auto conn = UniverseConnection(TcpPacketSocket::open(move(socket)));
-      server.addConnection(++clientId, move(conn));
+      auto conn = UniverseConnection(TcpPacketSocket::open(std::move(socket)));
+      server.addConnection(++clientId, std::move(conn));
     });
 
   LinkedList<ASyncClientThread> localASyncClients;
   for (unsigned i = 0; i < NumLocalASyncConnections; ++i) {
     auto pair = LocalPacketSocket::openPair();
-    server.addConnection(++clientId, UniverseConnection(move(pair.first)));
-    localASyncClients.emplaceAppend(UniverseConnection(move(pair.second)));
+    server.addConnection(++clientId, UniverseConnection(std::move(pair.first)));
+    localASyncClients.emplaceAppend(UniverseConnection(std::move(pair.second)));
   }
 
   LinkedList<SyncClientThread> localSyncClients;
   for (unsigned i = 0; i < NumLocalSyncConnections; ++i) {
     auto pair = LocalPacketSocket::openPair();
-    server.addConnection(++clientId, UniverseConnection(move(pair.first)));
-    localSyncClients.emplaceAppend(UniverseConnection(move(pair.second)));
+    server.addConnection(++clientId, UniverseConnection(std::move(pair.first)));
+    localSyncClients.emplaceAppend(UniverseConnection(std::move(pair.second)));
   }
 
   LinkedList<ASyncClientThread> remoteASyncClients;
   for (unsigned i = 0; i < NumRemoteASyncConnections; ++i) {
     auto socket = TcpSocket::connectTo({HostAddress::localhost(), ServerPort});
     socket->setNonBlocking(true);
-    remoteASyncClients.emplaceAppend(UniverseConnection(TcpPacketSocket::open(move(socket))));
+    remoteASyncClients.emplaceAppend(UniverseConnection(TcpPacketSocket::open(std::move(socket))));
   }
 
   LinkedList<SyncClientThread> remoteSyncClients;
   for (unsigned i = 0; i < NumRemoteSyncConnections; ++i) {
     auto socket = TcpSocket::connectTo({HostAddress::localhost(), ServerPort});
     socket->setNonBlocking(true);
-    remoteSyncClients.emplaceAppend(UniverseConnection(TcpPacketSocket::open(move(socket))));
+    remoteSyncClients.emplaceAppend(UniverseConnection(TcpPacketSocket::open(std::move(socket))));
   }
 
   for (auto& c : localASyncClients)
diff --git a/source/test/variant_test.cpp b/source/test/variant_test.cpp
index 03cb4e9..e8a8bcd 100644
--- a/source/test/variant_test.cpp
+++ b/source/test/variant_test.cpp
@@ -26,8 +26,8 @@ TEST(VariantTest, All) {
   b = VariantTester{intptr};
   a = b;
   a = a;
-  b = move(a);
-  a = move(b);
+  b = std::move(a);
+  a = std::move(b);
   EXPECT_EQ(intptr.use_count(), 2);
   a.reset();
   EXPECT_EQ(intptr.use_count(), 1);
@@ -59,8 +59,8 @@ TEST(MaybeTest, All) {
   EXPECT_TRUE(a.isValid());
   a = b;
   a = a;
-  b = move(a);
-  a = move(b);
+  b = std::move(a);
+  a = std::move(b);
   EXPECT_EQ(intptr.use_count(), 2);
   a = {};
   EXPECT_FALSE(a.isValid());
diff --git a/source/utility/asset_unpacker.cpp b/source/utility/asset_unpacker.cpp
index 487d0b7..9e5d5f3 100644
--- a/source/utility/asset_unpacker.cpp
+++ b/source/utility/asset_unpacker.cpp
@@ -42,7 +42,7 @@ int main(int argc, char** argv) {
 
     auto metadata = assetsPack.metadata();
     if (!metadata.empty())
-      File::writeFile(Json(move(metadata)).printJson(2), "_metadata");
+      File::writeFile(Json(std::move(metadata)).printJson(2), "_metadata");
 
     coutf("Unpacked assets to {} in {}s\n", outputFolderPath, Time::monotonicTime() - startTime);
     return 0;
diff --git a/source/utility/btree_repacker.cpp b/source/utility/btree_repacker.cpp
index ee65609..4276571 100644
--- a/source/utility/btree_repacker.cpp
+++ b/source/utility/btree_repacker.cpp
@@ -22,7 +22,7 @@ int main(int argc, char** argv) {
     outputFilename = File::relativeTo(File::fullPath(File::dirName(outputFilename)), File::baseName(outputFilename));
     //open the old db
     BTreeDatabase db;
-    db.setIODevice(std::move(File::open(bTreePath, IOMode::Read)));
+    db.setIODevice(File::open(bTreePath, IOMode::Read));
     db.open();
 
     //make a new db
@@ -32,7 +32,7 @@ int main(int argc, char** argv) {
     newDb.setKeySize(db.keySize());
     newDb.setAutoCommit(false);
 
-    newDb.setIODevice(std::move(File::open(outputFilename, IOMode::ReadWrite | IOMode::Truncate)));
+    newDb.setIODevice(File::open(outputFilename, IOMode::ReadWrite | IOMode::Truncate));
     newDb.open();
     coutf("Repacking {}...\n", bTreePath);
     //copy the data over
diff --git a/source/utility/dungeon_generation_benchmark.cpp b/source/utility/dungeon_generation_benchmark.cpp
index 70cbe9e..1467e02 100644
--- a/source/utility/dungeon_generation_benchmark.cpp
+++ b/source/utility/dungeon_generation_benchmark.cpp
@@ -47,7 +47,7 @@ int main(int argc, char** argv) {
 
       VisitableWorldParametersPtr worldParameters = generateFloatingDungeonWorldParameters(dungeonWorldName);
       auto worldTemplate = make_shared<WorldTemplate>(worldParameters, SkyParameters(), 1234);
-      WorldServer worldServer(move(worldTemplate), File::ephemeralFile());
+      WorldServer worldServer(std::move(worldTemplate), File::ephemeralFile());
     }
 
     coutf("Finished {} generations of dungeonWorld {} in {} seconds", repetitions, dungeonWorldName, Time::monotonicTime() - start);
diff --git a/source/utility/game_repl.cpp b/source/utility/game_repl.cpp
index 3ffc300..08ea8e1 100644
--- a/source/utility/game_repl.cpp
+++ b/source/utility/game_repl.cpp
@@ -22,7 +22,7 @@ int main(int argc, char** argv) {
     auto getline = [](std::istream& stream) -> String {
       std::string line;
       std::getline(stream, line);
-      return String(move(line));
+      return String(std::move(line));
     };
 
     if (continuation) {
diff --git a/source/utility/generation_benchmark.cpp b/source/utility/generation_benchmark.cpp
index 8e1631c..c96095e 100644
--- a/source/utility/generation_benchmark.cpp
+++ b/source/utility/generation_benchmark.cpp
@@ -51,7 +51,7 @@ int main(int argc, char** argv) {
 
     auto rand = RandomSource(worldTemplate->worldSeed());
 
-    WorldServer worldServer(move(worldTemplate), File::ephemeralFile());
+    WorldServer worldServer(std::move(worldTemplate), File::ephemeralFile());
     Vec2U worldSize = worldServer.geometry().size();
 
     double start = Time::monotonicTime();
diff --git a/source/windowing/StarButtonWidget.cpp b/source/windowing/StarButtonWidget.cpp
index c052599..c19fb4b 100644
--- a/source/windowing/StarButtonWidget.cpp
+++ b/source/windowing/StarButtonWidget.cpp
@@ -195,7 +195,7 @@ void ButtonWidget::setButtonGroup(ButtonGroupPtr newGroup, int id) {
     if (m_buttonGroup)
       m_buttonGroup->removeButton(this);
 
-    m_buttonGroup = move(newGroup);
+    m_buttonGroup = std::move(newGroup);
 
     if (m_buttonGroup) {
       setCheckable(true);
diff --git a/source/windowing/StarCanvasWidget.cpp b/source/windowing/StarCanvasWidget.cpp
index 0c7ea82..16ec994 100644
--- a/source/windowing/StarCanvasWidget.cpp
+++ b/source/windowing/StarCanvasWidget.cpp
@@ -27,28 +27,28 @@ void CanvasWidget::clear() {
 }
 
 void CanvasWidget::drawImage(String texName, Vec2F const& position, float scale, Vec4B const& color) {
-  m_renderOps.append(make_tuple(move(texName), position, scale, color, false));
+  m_renderOps.append(make_tuple(std::move(texName), position, scale, color, false));
 }
 
 void CanvasWidget::drawImageCentered(String texName, Vec2F const& position, float scale, Vec4B const& color) {
-  m_renderOps.append(make_tuple(move(texName), position, scale, color, true));
+  m_renderOps.append(make_tuple(std::move(texName), position, scale, color, true));
 }
 
 void CanvasWidget::drawImageRect(String texName, RectF const& texCoords, RectF const& screenCoords, Vec4B const& color) {
-  m_renderOps.append(make_tuple(move(texName), texCoords, screenCoords, color));
+  m_renderOps.append(make_tuple(std::move(texName), texCoords, screenCoords, color));
 }
 
 void CanvasWidget::drawDrawable(Drawable drawable, Vec2F const& screenPos) {
-  m_renderOps.append(make_tuple(move(drawable), screenPos));
+  m_renderOps.append(make_tuple(std::move(drawable), screenPos));
 }
 
 void CanvasWidget::drawDrawables(List<Drawable> drawables, Vec2F const& screenPos) {
   for (auto& drawable : drawables)
-    drawDrawable(move(drawable), screenPos);
+    drawDrawable(std::move(drawable), screenPos);
 }
 
 void CanvasWidget::drawTiledImage(String texName, float textureScale, Vec2D const& offset, RectF const& screenCoords, Vec4B const& color) {
-  m_renderOps.append(make_tuple(move(texName), textureScale, offset, screenCoords, color));
+  m_renderOps.append(make_tuple(std::move(texName), textureScale, offset, screenCoords, color));
 }
 
 void CanvasWidget::drawLine(Vec2F const& begin, Vec2F const end, Vec4B const& color, float lineWidth) {
@@ -68,7 +68,7 @@ void CanvasWidget::drawTriangles(List<tuple<Vec2F, Vec2F, Vec2F>> const& triangl
 }
 
 void CanvasWidget::drawText(String s, TextPositioning position, unsigned fontSize, Vec4B const& color, FontMode mode, float lineSpacing, String font, String processingDirectives) {
-  m_renderOps.append(make_tuple(move(s), move(position), fontSize, color, mode, lineSpacing, move(font), move(processingDirectives)));
+  m_renderOps.append(make_tuple(std::move(s), std::move(position), fontSize, color, mode, lineSpacing, std::move(font), std::move(processingDirectives)));
 }
 
 Vec2I CanvasWidget::mousePosition() const {
@@ -174,10 +174,10 @@ void CanvasWidget::renderImageRect(Vec2F const& renderingOffset, String const& t
 void CanvasWidget::renderDrawable(Vec2F const& renderingOffset, Drawable drawable, Vec2F const& screenPos) {
   auto& context = GuiContext::singleton();
   if (m_ignoreInterfaceScale)
-    context.drawDrawable(move(drawable), renderingOffset + screenPos, 1);
+    context.drawDrawable(std::move(drawable), renderingOffset + screenPos, 1);
   else {
     drawable.scale(context.interfaceScale());
-    context.drawDrawable(move(drawable), renderingOffset * context.interfaceScale() + screenPos * context.interfaceScale(), 1);
+    context.drawDrawable(std::move(drawable), renderingOffset * context.interfaceScale() + screenPos * context.interfaceScale(), 1);
   }
 }
 
diff --git a/source/windowing/StarGuiContext.cpp b/source/windowing/StarGuiContext.cpp
index 028614a..d1be94a 100644
--- a/source/windowing/StarGuiContext.cpp
+++ b/source/windowing/StarGuiContext.cpp
@@ -26,8 +26,8 @@ GuiContext::GuiContext(MixerPtr mixer, ApplicationControllerPtr appController) {
 
   s_singleton = this;
 
-  m_mixer = move(mixer);
-  m_applicationController = move(appController);
+  m_mixer = std::move(mixer);
+  m_applicationController = std::move(appController);
 
   m_interfaceScale = 1;
 
@@ -41,7 +41,7 @@ GuiContext::~GuiContext() {
 }
 
 void GuiContext::renderInit(RendererPtr renderer) {
-  m_renderer = move(renderer);
+  m_renderer = std::move(renderer);
   auto textureGroup = m_renderer->createTextureGroup();
   m_textureCollection = make_shared<AssetTextureGroup>(textureGroup);
   m_drawablePainter = make_shared<DrawablePainter>(m_renderer, m_textureCollection);
@@ -197,7 +197,7 @@ void GuiContext::drawTriangles(List<tuple<Vec2F, Vec2F, Vec2F>> const& triangles
 }
 
 void GuiContext::drawInterfaceDrawable(Drawable drawable, Vec2F const& screenPos, Vec4B const& color) {
-  drawDrawable(move(drawable), screenPos * interfaceScale(), (float)interfaceScale(), color);
+  drawDrawable(std::move(drawable), screenPos * interfaceScale(), (float)interfaceScale(), color);
 }
 
 void GuiContext::drawInterfaceLine(Vec2F const& begin, Vec2F const end, Vec4B const& color, float lineWidth) {
@@ -428,7 +428,7 @@ void GuiContext::playAudio(String const& audioAsset, int loops, float volume, fl
   audioInstance->setVolume(volume);
   audioInstance->setPitchMultiplier(pitch);
   audioInstance->setLoops(loops);
-  m_mixer->play(move(audioInstance));
+  m_mixer->play(std::move(audioInstance));
 }
 
 String GuiContext::getClipboard() const {
@@ -436,7 +436,7 @@ String GuiContext::getClipboard() const {
 }
 
 void GuiContext::setClipboard(String text) {
-  m_applicationController->setClipboard(move(text));
+  m_applicationController->setClipboard(std::move(text));
 }
 
 void GuiContext::cleanup() {
diff --git a/source/windowing/StarImageWidget.cpp b/source/windowing/StarImageWidget.cpp
index ef82c33..1a61b1e 100644
--- a/source/windowing/StarImageWidget.cpp
+++ b/source/windowing/StarImageWidget.cpp
@@ -48,7 +48,7 @@ String ImageWidget::image() const {
 }
 
 void ImageWidget::setDrawables(List<Drawable> drawables) {
-  m_baseDrawables = move(drawables);
+  m_baseDrawables = std::move(drawables);
 
   transformDrawables();
 }
diff --git a/source/windowing/StarKeyBindings.cpp b/source/windowing/StarKeyBindings.cpp
index 969a766..d082a3e 100644
--- a/source/windowing/StarKeyBindings.cpp
+++ b/source/windowing/StarKeyBindings.cpp
@@ -163,7 +163,7 @@ KeyBindings::KeyBindings(Json const& json) {
       }
     }
 
-    m_actions = move(actions);
+    m_actions = std::move(actions);
   } catch (StarException const& e) {
     throw StarException(strf("Could not set keybindings from configuration. {}", outputException(e, false)));
   }
diff --git a/source/windowing/StarLabelWidget.cpp b/source/windowing/StarLabelWidget.cpp
index b55ecc1..35f8618 100644
--- a/source/windowing/StarLabelWidget.cpp
+++ b/source/windowing/StarLabelWidget.cpp
@@ -10,18 +10,18 @@ LabelWidget::LabelWidget(String text,
     VerticalAnchor const& vAnchor,
     Maybe<unsigned> wrapWidth,
     Maybe<float> lineSpacing)
-  : m_color(color),
+  : m_fontMode(FontMode::Normal),
+    m_color(color),
     m_hAnchor(hAnchor),
     m_vAnchor(vAnchor),
-    m_wrapWidth(move(wrapWidth)),
-    m_lineSpacing(move(lineSpacing)),
-    m_fontMode(FontMode::Normal) {
+    m_wrapWidth(std::move(wrapWidth)),
+    m_lineSpacing(std::move(lineSpacing)) {
   auto assets = Root::singleton().assets();
   auto fontConfig = assets->json("/interface.config:font");
   m_fontSize = fontConfig.getInt("baseSize");
   m_processingDirectives = fontConfig.getString("defaultDirectives");
   m_font = fontConfig.queryString("defaultFont", "");
-  setText(move(text));
+  setText(std::move(text));
 }
 
 String const& LabelWidget::text() const {
@@ -33,7 +33,7 @@ Maybe<unsigned> LabelWidget::getTextCharLimit() const {
 }
 
 void LabelWidget::setText(String newText) {
-  m_text = move(newText);
+  m_text = std::move(newText);
   updateTextRegion();
 }
 
@@ -47,7 +47,7 @@ void LabelWidget::setFontMode(FontMode fontMode) {
 }
 
 void LabelWidget::setColor(Color newColor) {
-  m_color = move(newColor);
+  m_color = std::move(newColor);
 }
 
 void LabelWidget::setAnchor(HorizontalAnchor hAnchor, VerticalAnchor vAnchor) {
@@ -57,12 +57,12 @@ void LabelWidget::setAnchor(HorizontalAnchor hAnchor, VerticalAnchor vAnchor) {
 }
 
 void LabelWidget::setWrapWidth(Maybe<unsigned> wrapWidth) {
-  m_wrapWidth = move(wrapWidth);
+  m_wrapWidth = std::move(wrapWidth);
   updateTextRegion();
 }
 
 void LabelWidget::setLineSpacing(Maybe<float> lineSpacing) {
-  m_lineSpacing = move(lineSpacing);
+  m_lineSpacing = std::move(lineSpacing);
   updateTextRegion();
 }
 
diff --git a/source/windowing/StarListWidget.cpp b/source/windowing/StarListWidget.cpp
index c5ac35b..bb8161b 100644
--- a/source/windowing/StarListWidget.cpp
+++ b/source/windowing/StarListWidget.cpp
@@ -29,7 +29,7 @@ RectI ListWidget::relativeBoundRect() const {
 }
 
 void ListWidget::setCallback(WidgetCallbackFunc callback) {
-  m_callback = move(callback);
+  m_callback = std::move(callback);
 }
 
 bool ListWidget::sendEvent(InputEvent const& event) {
diff --git a/source/windowing/StarPane.cpp b/source/windowing/StarPane.cpp
index 39ad24c..b1a3daa 100644
--- a/source/windowing/StarPane.cpp
+++ b/source/windowing/StarPane.cpp
@@ -169,7 +169,7 @@ void Pane::setFocus(Widget const* focus) {
   if (m_focusWidget)
     m_focusWidget->blur();
   if (auto c = childPtr(focus))
-    m_focusWidget = move(c);
+    m_focusWidget = std::move(c);
   else
     throw GuiException("Cannot set focus on a widget which is not a child of this pane");
 }
@@ -366,7 +366,7 @@ LuaCallbacks Pane::makePaneCallbacks() {
       audioInstance->setLoops(loops.value(0));
       auto& guiContext = GuiContext::singleton();
       guiContext.playAudio(audioInstance);
-      m_playingSounds.append({audio, move(audioInstance)});
+      m_playingSounds.append({audio, std::move(audioInstance)});
     });
 
   callbacks.registerCallback("stopAllSounds", [this](Maybe<String> const& audio) {
diff --git a/source/windowing/StarPaneManager.cpp b/source/windowing/StarPaneManager.cpp
index f44783c..4f4cee7 100644
--- a/source/windowing/StarPaneManager.cpp
+++ b/source/windowing/StarPaneManager.cpp
@@ -25,7 +25,7 @@ PaneManager::PaneManager()
 }
 
 void PaneManager::displayPane(PaneLayer paneLayer, PanePtr const& pane, DismissCallback onDismiss) {
-  if (!m_displayedPanes[paneLayer].insertFront(pane, move(onDismiss)).second)
+  if (!m_displayedPanes[paneLayer].insertFront(pane, std::move(onDismiss)).second)
     throw GuiException("Pane displayed twice in PaneManager::displayPane");
 
   if (!pane->hasDisplayed() && pane->anchor() == PaneAnchor::None)
@@ -274,8 +274,8 @@ void PaneManager::update(float dt) {
   if (m_tooltipShowTimer < 0 && !m_activeTooltip) {
     if (auto parentPane = getPaneAt(m_tooltipLastMousePos)) {
       if (auto tooltip = parentPane->createTooltip(m_tooltipLastMousePos)) {
-        m_activeTooltip = move(tooltip);
-        m_tooltipParentPane = move(parentPane);
+        m_activeTooltip = std::move(tooltip);
+        m_tooltipParentPane = std::move(parentPane);
         m_tooltipInitialPosition = m_tooltipLastMousePos;
         displayPane(PaneLayer::Tooltip, m_activeTooltip);
 
diff --git a/source/windowing/StarRegisteredPaneManager.hpp b/source/windowing/StarRegisteredPaneManager.hpp
index ebb158d..a33423a 100644
--- a/source/windowing/StarRegisteredPaneManager.hpp
+++ b/source/windowing/StarRegisteredPaneManager.hpp
@@ -66,7 +66,7 @@ shared_ptr<T> RegisteredPaneManager<KeyT>::maybeRegisteredPane(KeyT const& paneI
 template <typename KeyT>
 void RegisteredPaneManager<KeyT>::registerPane(
     KeyT paneId, PaneLayer paneLayer, PanePtr pane, DismissCallback onDismiss) {
-  if (!m_registeredPanes.insert(move(paneId), {move(paneLayer), move(pane), move(onDismiss)}).second)
+  if (!m_registeredPanes.insert(std::move(paneId), {std::move(paneLayer), std::move(pane), std::move(onDismiss)}).second)
     throw GuiException(
         strf("Registered pane with name '{}' registered a second time in RegisteredPaneManager::registerPane",
             outputAny(paneId)));
diff --git a/source/windowing/StarTabSet.cpp b/source/windowing/StarTabSet.cpp
index b968feb..a764cec 100644
--- a/source/windowing/StarTabSet.cpp
+++ b/source/windowing/StarTabSet.cpp
@@ -86,7 +86,7 @@ size_t TabSetWidget::selectedTab() const {
 }
 
 void TabSetWidget::setCallback(WidgetCallbackFunc callback) {
-  m_callback = move(callback);
+  m_callback = std::move(callback);
 }
 
 }
diff --git a/source/windowing/StarWidgetLuaBindings.cpp b/source/windowing/StarWidgetLuaBindings.cpp
index f69bd53..5b59d48 100644
--- a/source/windowing/StarWidgetLuaBindings.cpp
+++ b/source/windowing/StarWidgetLuaBindings.cpp
@@ -26,13 +26,13 @@ LuaMethods<CanvasWidgetPtr> LuaUserDataMethods<CanvasWidgetPtr>::make() {
   methods.registerMethodWithSignature<void, CanvasWidgetPtr>("clear", mem_fn(&CanvasWidget::clear));
 
   methods.registerMethod("drawDrawable", [](CanvasWidgetPtr canvasWidget, Drawable drawable, Maybe<Vec2F> screenPos) {
-    canvasWidget->drawDrawable(move(drawable), screenPos.value(Vec2F()));
+    canvasWidget->drawDrawable(std::move(drawable), screenPos.value(Vec2F()));
   });
 
   methods.registerMethod("drawDrawables", [](CanvasWidgetPtr canvasWidget, List<Drawable> drawables, Maybe<Vec2F> screenPos) {
     Vec2F pos = screenPos.value(Vec2F());
     for (auto& drawable : drawables)
-      canvasWidget->drawDrawable(move(drawable), pos);
+      canvasWidget->drawDrawable(std::move(drawable), pos);
   });
 
   methods.registerMethod("drawImage",