Fixed a huge amount of Clang warnings

On Linux and macOS, using Clang to compile OpenStarbound produces about 400 MB worth of warnings during the build, making the compiler output unreadable and slowing the build down considerably.

99% of the warnings were unqualified uses of std::move and std::forward, which are now all properly qualified.

Fixed a few other minor warnings about non-virtual destructors and some uses of std::move preventing copy elision on temporary objects.

Most remaining warnings are now unused parameters.

274 files changed, 1455 insertions, 1444 deletions

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 183b00a..f41e034 100644
--- a/source/core/StarImage.cpp
+++ b/source/core/StarImage.cpp
@@ -217,7 +217,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..27519bb 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 std::move(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..9e5a4a2 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 std::move(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..e3f9d67 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 std::move(v);
   }
 
   return {};
@@ -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..8c787e0 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 std::move(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..870881f 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 std::move(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 3a4a7cc..51987e1 100644
--- a/source/core/StarStaticVector.hpp
+++ b/source/core/StarStaticVector.hpp
@@ -115,7 +115,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>
@@ -162,7 +162,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;
 }
@@ -171,7 +171,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;
 }
 
@@ -274,7 +274,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>
@@ -287,7 +287,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;
 }
 
@@ -302,7 +302,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++;
@@ -321,8 +321,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>
@@ -332,7 +332,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>
@@ -345,7 +345,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;
 }
@@ -356,7 +356,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 40fc8d1..572cbd7 100644
--- a/source/frontend/StarCinematic.cpp
+++ b/source/frontend/StarCinematic.cpp
@@ -197,7 +197,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))) {
@@ -205,7 +205,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()) {
@@ -274,7 +274,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 a0ed3ae..ec4684b 100644
--- a/source/frontend/StarMainInterface.cpp
+++ b/source/frontend/StarMainInterface.cpp
@@ -1142,7 +1142,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 168d23b..f7155e6 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..8dcf8e9 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 std::move(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 std::move(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 std::move(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 std::move(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 fb5cea5..4586889 100644
--- a/source/game/StarSystemWorldServerThread.cpp
+++ b/source/game/StarSystemWorldServerThread.cpp
@@ -7,7 +7,7 @@ namespace Star {
 SystemWorldServerThread::SystemWorldServerThread(Vec3I const& location, SystemWorldServerPtr systemWorld, String storageFile)
   : Thread(strf("SystemWorldServer: {}", location)), m_stop(false), m_storageFile(storageFile) {
   m_systemLocation = location;
-  m_systemWorld = move(systemWorld);
+  m_systemWorld = std::move(systemWorld);
 }
 
 SystemWorldServerThread::~SystemWorldServerThread() {
@@ -45,7 +45,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() {
@@ -125,7 +125,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) {
@@ -158,7 +158,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..9d710d4 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 std::move(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",