Merge pull request #19 from kblaschke/fix-compiler-warnings

Fixed a huge amount of Clang warnings

89 files changed, 598 insertions, 598 deletions

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..a98e7e5 100644
--- a/source/core/StarImageProcessing.cpp
+++ b/source/core/StarImageProcessing.cpp
@@ -201,7 +201,7 @@ ImageOperation imageOperationFromString(StringView string) {
             else if (!which || (ptr != end && ++ptr != end))
                 throw ImageOperationException(strf("Improper size for hex string '{}' in imageOperationFromString", StringView(hexPtr, hexLen)), false);
             else // we're in A of A=B. In vanilla only A=B pairs are evaluated, so only throw an exception if B is also there.
-                return move(operation);
+                return operation;
               
 
             which = !which;
diff --git a/source/core/StarInterpolation.hpp b/source/core/StarInterpolation.hpp
index 1797495..426f37d 100644
--- a/source/core/StarInterpolation.hpp
+++ b/source/core/StarInterpolation.hpp
@@ -369,7 +369,7 @@ Pos inverseLinearInterpolateLower(Iterator begin, Iterator end, Pos t, Comp&& co
   if (begin == end || std::next(begin) == end)
     return Pos();
 
-  Iterator i = std::lower_bound(std::next(begin), std::prev(end), t, forward<Comp>(comp));
+  Iterator i = std::lower_bound(std::next(begin), std::prev(end), t, std::forward<Comp>(comp));
 
   --i;
   Pos min = posGetter(*i);
@@ -396,7 +396,7 @@ Pos inverseLinearInterpolateUpper(Iterator begin, Iterator end, Pos t, Comp&& co
   if (begin == end || std::next(begin) == end)
     return Pos();
 
-  Iterator i = std::upper_bound(std::next(begin), std::prev(end), t, forward<Comp>(comp));
+  Iterator i = std::upper_bound(std::next(begin), std::prev(end), t, std::forward<Comp>(comp));
 
   --i;
   Pos min = posGetter(*i);
diff --git a/source/core/StarIterator.hpp b/source/core/StarIterator.hpp
index 7770d84..389740a 100644
--- a/source/core/StarIterator.hpp
+++ b/source/core/StarIterator.hpp
@@ -137,7 +137,7 @@ public:
   }
 
   void insert(value_type v) {
-    curr = ++cont.insert(curr, move(v));
+    curr = ++cont.insert(curr, std::move(v));
     direction = -1;
   }
 
@@ -178,7 +178,7 @@ public:
   }
 
   void setValue(value_type v) const {
-    value() = move(v);
+    value() = std::move(v);
   }
 
   value_ref next() {
diff --git a/source/core/StarJson.cpp b/source/core/StarJson.cpp
index 2892e1c..3feaf37 100644
--- a/source/core/StarJson.cpp
+++ b/source/core/StarJson.cpp
@@ -745,7 +745,7 @@ Maybe<JsonObject> Json::optQueryObject(String const& path) const {
 
 Json Json::set(String key, Json value) const {
   auto map = toObject();
-  map[move(key)] = move(value);
+  map[std::move(key)] = std::move(value);
   return map;
 }
 
@@ -760,31 +760,31 @@ Json Json::erasePath(String path) const {
 Json Json::setAll(JsonObject values) const {
   auto map = toObject();
   for (auto& p : values)
-    map[move(p.first)] = move(p.second);
+    map[std::move(p.first)] = std::move(p.second);
   return map;
 }
 
 Json Json::eraseKey(String key) const {
   auto map = toObject();
-  map.erase(move(key));
+  map.erase(std::move(key));
   return map;
 }
 
 Json Json::set(size_t index, Json value) const {
   auto array = toArray();
-  array[index] = move(value);
+  array[index] = std::move(value);
   return array;
 }
 
 Json Json::insert(size_t index, Json value) const {
   auto array = toArray();
-  array.insertAt(index, move(value));
+  array.insertAt(index, std::move(value));
   return array;
 }
 
 Json Json::append(Json value) const {
   auto array = toArray();
-  array.append(move(value));
+  array.append(std::move(value));
   return array;
 }
 
@@ -927,7 +927,7 @@ DataStream& operator>>(DataStream& os, Json& v) {
     for (size_t i = 0; i < s; ++i)
       l.append(os.read<Json>());
 
-    v = move(l);
+    v = std::move(l);
   } else if (type == Json::Type::Object) {
     JsonObject m;
     size_t s = os.readVlqU();
@@ -936,7 +936,7 @@ DataStream& operator>>(DataStream& os, Json& v) {
       m[k] = os.read<Json>();
     }
 
-    v = move(m);
+    v = std::move(m);
   }
 
   return os;
diff --git a/source/core/StarJsonBuilder.cpp b/source/core/StarJsonBuilder.cpp
index 6355666..14b45a1 100644
--- a/source/core/StarJsonBuilder.cpp
+++ b/source/core/StarJsonBuilder.cpp
@@ -15,12 +15,12 @@ void JsonBuilderStream::endObject() {
   JsonObject object;
   while (true) {
     if (isSentry()) {
-      set(Json(move(object)));
+      set(Json(std::move(object)));
       return;
     } else {
       Json v = pop();
       String k = pop().toString();
-      if (!object.insert(k, move(v)).second)
+      if (!object.insert(k, std::move(v)).second)
         throw JsonParsingException(strf("Json object contains a duplicate entry for key '{}'", k));
     }
   }
@@ -35,7 +35,7 @@ void JsonBuilderStream::endArray() {
   while (true) {
     if (isSentry()) {
       array.reverse();
-      set(Json(move(array)));
+      set(Json(std::move(array)));
       return;
     } else {
       array.append(pop());
@@ -81,7 +81,7 @@ Json JsonBuilderStream::takeTop() {
 }
 
 void JsonBuilderStream::push(Json v) {
-  m_stack.append(move(v));
+  m_stack.append(std::move(v));
 }
 
 Json JsonBuilderStream::pop() {
@@ -89,7 +89,7 @@ Json JsonBuilderStream::pop() {
 }
 
 void JsonBuilderStream::set(Json v) {
-  m_stack.last() = move(v);
+  m_stack.last() = std::move(v);
 }
 
 void JsonBuilderStream::pushSentry() {
diff --git a/source/core/StarJsonExtra.cpp b/source/core/StarJsonExtra.cpp
index ec6fe90..dcf2bf6 100644
--- a/source/core/StarJsonExtra.cpp
+++ b/source/core/StarJsonExtra.cpp
@@ -372,7 +372,7 @@ List<Color> jsonToColorList(Json const& v) {
 List<Directives> jsonToDirectivesList(Json const& v) {
   List<Directives> result;
   for (auto const& entry : v.iterateArray())
-    result.append(move(entry.toString()));
+    result.append(entry.toString());
   return result;
 }
 
diff --git a/source/core/StarJsonExtra.hpp b/source/core/StarJsonExtra.hpp
index 66d89d6..98de98b 100644
--- a/source/core/StarJsonExtra.hpp
+++ b/source/core/StarJsonExtra.hpp
@@ -262,7 +262,7 @@ MapType jsonToMapK(Json const& v, KeyConverter&& keyConvert) {
 
 template <typename MapType, typename ValueConverter>
 MapType jsonToMapV(Json const& v, ValueConverter&& valueConvert) {
-  return jsonToMapKV<MapType>(v, construct<typename MapType::key_type>(), forward<ValueConverter>(valueConvert));
+  return jsonToMapKV<MapType>(v, construct<typename MapType::key_type>(), std::forward<ValueConverter>(valueConvert));
 }
 
 template <typename MapType>
@@ -281,12 +281,12 @@ Json jsonFromMapKV(MapType const& map, KeyConverter&& keyConvert, ValueConverter
 
 template <typename MapType, typename KeyConverter>
 Json jsonFromMapK(MapType const& map, KeyConverter&& keyConvert) {
-  return jsonFromMapKV<MapType>(map, forward<KeyConverter>(keyConvert), construct<Json>());
+  return jsonFromMapKV<MapType>(map, std::forward<KeyConverter>(keyConvert), construct<Json>());
 }
 
 template <typename MapType, typename ValueConverter>
 Json jsonFromMapV(MapType const& map, ValueConverter&& valueConvert) {
-  return jsonFromMapKV<MapType>(map, construct<String>(), forward<ValueConverter>(valueConvert));
+  return jsonFromMapKV<MapType>(map, construct<String>(), std::forward<ValueConverter>(valueConvert));
 }
 
 template <typename MapType>
diff --git a/source/core/StarJsonParser.hpp b/source/core/StarJsonParser.hpp
index fc14d84..522f434 100644
--- a/source/core/StarJsonParser.hpp
+++ b/source/core/StarJsonParser.hpp
@@ -462,7 +462,7 @@ private:
   }
 
   void error(std::string msg) {
-    m_error = move(msg);
+    m_error = std::move(msg);
     throw ParsingException();
   }
 
diff --git a/source/core/StarJsonRpc.cpp b/source/core/StarJsonRpc.cpp
index f6def8f..c8b59a5 100644
--- a/source/core/StarJsonRpc.cpp
+++ b/source/core/StarJsonRpc.cpp
@@ -13,7 +13,7 @@ JsonRpc::JsonRpc() {
 void JsonRpc::registerHandler(String const& handler, JsonRpcRemoteFunction func) {
   if (m_handlers.contains(handler))
     throw JsonRpcException(strf("Handler by that name already exists '{}'", handler));
-  m_handlers.add(handler, move(func));
+  m_handlers.add(handler, std::move(func));
 }
 
 void JsonRpc::registerHandlers(JsonRpcHandlers const& handlers) {
diff --git a/source/core/StarLexicalCast.hpp b/source/core/StarLexicalCast.hpp
index abda912..7c43137 100644
--- a/source/core/StarLexicalCast.hpp
+++ b/source/core/StarLexicalCast.hpp
@@ -30,7 +30,7 @@ Maybe<Type> maybeLexicalCast(StringView s, std::ios_base::fmtflags flags = std::
   if (stream >> ch)
     return {};
 
-  return move(result);
+  return result;
 }
 
 template <typename Type>
diff --git a/source/core/StarList.hpp b/source/core/StarList.hpp
index 49d2f84..cf7c6a6 100644
--- a/source/core/StarList.hpp
+++ b/source/core/StarList.hpp
@@ -451,7 +451,7 @@ void ListMixin<BaseList>::appendAll(Container&& list) {
 template <typename BaseList>
 template <class... Args>
 auto ListMixin<BaseList>::emplaceAppend(Args&&... args) -> reference {
-  Base::emplace_back(forward<Args>(args)...);
+  Base::emplace_back(std::forward<Args>(args)...);
   return *prev(Base::end());
 }
 
@@ -558,13 +558,13 @@ size_t ListMixin<BaseList>::remove(const_reference e) {
 template <typename BaseList>
 template <typename Filter>
 void ListMixin<BaseList>::filter(Filter&& filter) {
-  Star::filter(*this, forward<Filter>(filter));
+  Star::filter(*this, std::forward<Filter>(filter));
 }
 
 template <typename BaseList>
 template <typename Comparator>
 void ListMixin<BaseList>::insertSorted(value_type e, Comparator&& comparator) {
-  auto i = std::upper_bound(Base::begin(), Base::end(), e, forward<Comparator>(comparator));
+  auto i = std::upper_bound(Base::begin(), Base::end(), e, std::forward<Comparator>(comparator));
   Base::insert(i, std::move(e));
 }
 
@@ -577,7 +577,7 @@ void ListMixin<BaseList>::insertSorted(value_type e) {
 template <typename BaseList>
 template <typename Comparator>
 bool ListMixin<BaseList>::containsSorted(value_type const& e, Comparator&& comparator) {
-  auto range = std::equal_range(Base::begin(), Base::end(), e, forward<Comparator>(comparator));
+  auto range = std::equal_range(Base::begin(), Base::end(), e, std::forward<Comparator>(comparator));
   return range.first != range.second;
 }
 
@@ -611,7 +611,7 @@ void ListMixin<BaseList>::transform(Function&& function) {
 template <typename BaseList>
 template <typename Function>
 bool ListMixin<BaseList>::any(Function&& function) const {
-  return Star::any(*this, forward<Function>(function));
+  return Star::any(*this, std::forward<Function>(function));
 }
 
 template <typename BaseList>
@@ -622,7 +622,7 @@ bool ListMixin<BaseList>::any() const {
 template <typename BaseList>
 template <typename Function>
 bool ListMixin<BaseList>::all(Function&& function) const {
-  return Star::all(*this, forward<Function>(function));
+  return Star::all(*this, std::forward<Function>(function));
 }
 
 template <typename BaseList>
@@ -633,7 +633,7 @@ bool ListMixin<BaseList>::all() const {
 template <typename BaseList>
 template <typename Comparator>
 void RandomAccessListMixin<BaseList>::sort(Comparator&& comparator) {
-  Star::sort(*this, forward<Comparator>(comparator));
+  Star::sort(*this, std::forward<Comparator>(comparator));
 }
 
 template <typename BaseList>
@@ -790,7 +790,7 @@ void FrontModifyingListMixin<BaseList>::prependAll(Container&& list) {
 template <typename BaseList>
 template <class... Args>
 auto FrontModifyingListMixin<BaseList>::emplacePrepend(Args&&... args) -> reference {
-  Base::emplace_front(forward<Args>(args)...);
+  Base::emplace_front(std::forward<Args>(args)...);
   return *Base::begin();
 }
 
@@ -839,7 +839,7 @@ template <typename Element, typename Allocator>
 template <typename Filter>
 auto List<Element, Allocator>::filtered(Filter&& filter) const -> List {
   List list(*this);
-  list.filter(forward<Filter>(filter));
+  list.filter(std::forward<Filter>(filter));
   return list;
 }
 
@@ -847,7 +847,7 @@ template <typename Element, typename Allocator>
 template <typename Comparator>
 auto List<Element, Allocator>::sorted(Comparator&& comparator) const -> List {
   List list(*this);
-  list.sort(forward<Comparator>(comparator));
+  list.sort(std::forward<Comparator>(comparator));
   return list;
 }
 
@@ -863,7 +863,7 @@ template <typename Function>
 auto List<Element, Allocator>::transformed(Function&& function) {
   List<typename std::decay<decltype(std::declval<Function>()(std::declval<reference>()))>::type> res;
   res.reserve(Base::size());
-  transformInto(res, *this, forward<Function>(function));
+  transformInto(res, *this, std::forward<Function>(function));
   return res;
 }
 
@@ -872,7 +872,7 @@ template <typename Function>
 auto List<Element, Allocator>::transformed(Function&& function) const {
   List<typename std::decay<decltype(std::declval<Function>()(std::declval<const_reference>()))>::type> res;
   res.reserve(Base::size());
-  transformInto(res, *this, forward<Function>(function));
+  transformInto(res, *this, std::forward<Function>(function));
   return res;
 }
 
@@ -899,7 +899,7 @@ template <typename Element, size_t MaxSize>
 template <typename Comparator>
 auto StaticList<Element, MaxSize>::sorted(Comparator&& comparator) const -> StaticList {
   StaticList list(*this);
-  list.sort(forward<Comparator>(comparator));
+  list.sort(std::forward<Comparator>(comparator));
   return list;
 }
 
@@ -914,7 +914,7 @@ template <typename Element, size_t MaxSize>
 template <typename Function>
 auto StaticList<Element, MaxSize>::transformed(Function&& function) {
   StaticList<typename std::decay<decltype(std::declval<Function>()(std::declval<reference>()))>::type, MaxSize> res;
-  transformInto(res, *this, forward<Function>(function));
+  transformInto(res, *this, std::forward<Function>(function));
   return res;
 }
 
@@ -922,7 +922,7 @@ template <typename Element, size_t MaxSize>
 template <typename Function>
 auto StaticList<Element, MaxSize>::transformed(Function&& function) const {
   StaticList<typename std::decay<decltype(std::declval<Function>()(std::declval<const_reference>()))>::type, MaxSize> res;
-  transformInto(res, *this, forward<Function>(function));
+  transformInto(res, *this, std::forward<Function>(function));
   return res;
 }
 
@@ -941,7 +941,7 @@ template <typename Element, size_t MaxStackSize>
 template <typename Filter>
 auto SmallList<Element, MaxStackSize>::filtered(Filter&& filter) const -> SmallList {
   SmallList list(*this);
-  list.filter(forward<Filter>(filter));
+  list.filter(std::forward<Filter>(filter));
   return list;
 }
 
@@ -949,7 +949,7 @@ template <typename Element, size_t MaxStackSize>
 template <typename Comparator>
 auto SmallList<Element, MaxStackSize>::sorted(Comparator&& comparator) const -> SmallList {
   SmallList list(*this);
-  list.sort(forward<Comparator>(comparator));
+  list.sort(std::forward<Comparator>(comparator));
   return list;
 }
 
@@ -964,7 +964,7 @@ template <typename Element, size_t MaxStackSize>
 template <typename Function>
 auto SmallList<Element, MaxStackSize>::transformed(Function&& function) {
   SmallList<typename std::decay<decltype(std::declval<Function>()(std::declval<reference>()))>::type, MaxStackSize> res;
-  transformInto(res, *this, forward<Function>(function));
+  transformInto(res, *this, std::forward<Function>(function));
   return res;
 }
 
@@ -972,7 +972,7 @@ template <typename Element, size_t MaxStackSize>
 template <typename Function>
 auto SmallList<Element, MaxStackSize>::transformed(Function&& function) const {
   SmallList<typename std::decay<decltype(std::declval<Function>()(std::declval<const_reference>()))>::type, MaxStackSize> res;
-  transformInto(res, *this, forward<Function>(function));
+  transformInto(res, *this, std::forward<Function>(function));
   return res;
 }
 
@@ -991,7 +991,7 @@ template <typename Element, typename Allocator>
 template <typename Filter>
 Deque<Element, Allocator> Deque<Element, Allocator>::filtered(Filter&& filter) const {
   Deque l(*this);
-  l.filter(forward<Filter>(filter));
+  l.filter(std::forward<Filter>(filter));
   return l;
 }
 
@@ -999,7 +999,7 @@ template <typename Element, typename Allocator>
 template <typename Comparator>
 Deque<Element, Allocator> Deque<Element, Allocator>::sorted(Comparator&& comparator) const {
   Deque l(*this);
-  l.sort(forward<Comparator>(comparator));
+  l.sort(std::forward<Comparator>(comparator));
   return l;
 }
 
@@ -1013,13 +1013,13 @@ Deque<Element, Allocator> Deque<Element, Allocator>::sorted() const {
 template <typename Element, typename Allocator>
 template <typename Function>
 auto Deque<Element, Allocator>::transformed(Function&& function) {
-  return Star::transform<Deque<decltype(std::declval<Function>()(std::declval<reference>()))>>(*this, forward<Function>(function));
+  return Star::transform<Deque<decltype(std::declval<Function>()(std::declval<reference>()))>>(*this, std::forward<Function>(function));
 }
 
 template <typename Element, typename Allocator>
 template <typename Function>
 auto Deque<Element, Allocator>::transformed(Function&& function) const {
-  return Star::transform<Deque<decltype(std::declval<Function>()(std::declval<const_reference>()))>>(*this, forward<Function>(function));
+  return Star::transform<Deque<decltype(std::declval<Function>()(std::declval<const_reference>()))>>(*this, std::forward<Function>(function));
 }
 
 template <typename Element, typename Allocator>
@@ -1064,7 +1064,7 @@ template <typename Element, typename Allocator>
 template <typename Filter>
 LinkedList<Element, Allocator> LinkedList<Element, Allocator>::filtered(Filter&& filter) const {
   LinkedList list(*this);
-  list.filter(forward<Filter>(filter));
+  list.filter(std::forward<Filter>(filter));
   return list;
 }
 
@@ -1072,7 +1072,7 @@ template <typename Element, typename Allocator>
 template <typename Comparator>
 LinkedList<Element, Allocator> LinkedList<Element, Allocator>::sorted(Comparator&& comparator) const {
   LinkedList l(*this);
-  l.sort(forward<Comparator>(comparator));
+  l.sort(std::forward<Comparator>(comparator));
   return l;
 }
 
@@ -1086,13 +1086,13 @@ LinkedList<Element, Allocator> LinkedList<Element, Allocator>::sorted() const {
 template <typename Element, typename Allocator>
 template <typename Function>
 auto LinkedList<Element, Allocator>::transformed(Function&& function) {
-  return Star::transform<LinkedList<decltype(std::declval<Function>()(std::declval<reference>()))>>(*this, forward<Function>(function));
+  return Star::transform<LinkedList<decltype(std::declval<Function>()(std::declval<reference>()))>>(*this, std::forward<Function>(function));
 }
 
 template <typename Element, typename Allocator>
 template <typename Function>
 auto LinkedList<Element, Allocator>::transformed(Function&& function) const {
-  return Star::transform<LinkedList<decltype(std::declval<Function>()(std::declval<const_reference>()))>>(*this, forward<Function>(function));
+  return Star::transform<LinkedList<decltype(std::declval<Function>()(std::declval<const_reference>()))>>(*this, std::forward<Function>(function));
 }
 
 template <typename BaseList>
diff --git a/source/core/StarListener.cpp b/source/core/StarListener.cpp
index 642f2a2..394d55d 100644
--- a/source/core/StarListener.cpp
+++ b/source/core/StarListener.cpp
@@ -5,7 +5,7 @@ namespace Star {
 Listener::~Listener() {}
 
 CallbackListener::CallbackListener(function<void()> callback)
-  : callback(move(callback)) {}
+  : callback(std::move(callback)) {}
 
 void CallbackListener::trigger() {
   if (callback)
@@ -16,12 +16,12 @@ TrackerListener::TrackerListener() : triggered(false) {}
 
 void ListenerGroup::addListener(ListenerWeakPtr listener) {
   MutexLocker locker(m_mutex);
-  m_listeners.insert(move(listener));
+  m_listeners.insert(std::move(listener));
 }
 
 void ListenerGroup::removeListener(ListenerWeakPtr listener) {
   MutexLocker locker(m_mutex);
-  m_listeners.erase(move(listener));
+  m_listeners.erase(std::move(listener));
 }
 
 void ListenerGroup::clearExpiredListeners() {
diff --git a/source/core/StarLockFile_unix.cpp b/source/core/StarLockFile_unix.cpp
index 298c636..ab43d93 100644
--- a/source/core/StarLockFile_unix.cpp
+++ b/source/core/StarLockFile_unix.cpp
@@ -12,16 +12,16 @@ namespace Star {
 int64_t const LockFile::MaximumSleepMillis;
 
 Maybe<LockFile> LockFile::acquireLock(String const& filename, int64_t lockTimeout) {
-  LockFile lock(move(filename));
+  LockFile lock(std::move(filename));
   if (lock.lock(lockTimeout))
     return lock;
   return {};
 }
 
-LockFile::LockFile(String const& filename) : m_filename(move(filename)) {}
+LockFile::LockFile(String const& filename) : m_filename(std::move(filename)) {}
 
 LockFile::LockFile(LockFile&& lockFile) {
-  operator=(move(lockFile));
+  operator=(std::move(lockFile));
 }
 
 LockFile::~LockFile() {
@@ -29,8 +29,8 @@ LockFile::~LockFile() {
 }
 
 LockFile& LockFile::operator=(LockFile&& lockFile) {
-  m_filename = move(lockFile.m_filename);
-  m_handle = move(lockFile.m_handle);
+  m_filename = std::move(lockFile.m_filename);
+  m_handle = std::move(lockFile.m_handle);
 
   return *this;
 }
diff --git a/source/core/StarLockFile_windows.cpp b/source/core/StarLockFile_windows.cpp
index 33692fb..c6d7295 100644
--- a/source/core/StarLockFile_windows.cpp
+++ b/source/core/StarLockFile_windows.cpp
@@ -11,16 +11,16 @@ namespace Star {
 int64_t const LockFile::MaximumSleepMillis;
 
 Maybe<LockFile> LockFile::acquireLock(String const& filename, int64_t lockTimeout) {
-  LockFile lock(move(filename));
+  LockFile lock(std::move(filename));
   if (lock.lock(lockTimeout))
-    return move(lock);
+    return std::move(lock);
   return {};
 }
 
-LockFile::LockFile(String const& filename) : m_filename(move(filename)) {}
+LockFile::LockFile(String const& filename) : m_filename(std::move(filename)) {}
 
 LockFile::LockFile(LockFile&& lockFile) {
-  operator=(move(lockFile));
+  operator=(std::move(lockFile));
 }
 
 LockFile::~LockFile() {
@@ -28,8 +28,8 @@ LockFile::~LockFile() {
 }
 
 LockFile& LockFile::operator=(LockFile&& lockFile) {
-  m_filename = move(lockFile.m_filename);
-  m_handle = move(lockFile.m_handle);
+  m_filename = std::move(lockFile.m_filename);
+  m_handle = std::move(lockFile.m_handle);
 
   return *this;
 }
diff --git a/source/core/StarLogging.cpp b/source/core/StarLogging.cpp
index 19094f8..062facf 100644
--- a/source/core/StarLogging.cpp
+++ b/source/core/StarLogging.cpp
@@ -212,9 +212,9 @@ void SpatialLogger::clear() {
   decltype(s_logText) logText;
   {
     MutexLocker locker(s_mutex);
-    lines = move(s_lines);
-    points = move(s_points);
-    logText = move(s_logText);
+    lines = std::move(s_lines);
+    points = std::move(s_points);
+    logText = std::move(s_logText);
   } // Move while locked to deallocate contents while unlocked.
 }
 
diff --git a/source/core/StarLruCache.hpp b/source/core/StarLruCache.hpp
index d047a37..a59ed03 100644
--- a/source/core/StarLruCache.hpp
+++ b/source/core/StarLruCache.hpp
@@ -105,9 +105,9 @@ template <typename OrderedMapType>
 void LruCacheBase<OrderedMapType>::set(Key const& key, Value value) {
   auto i = m_map.find(key);
   if (i == m_map.end()) {
-    m_map.add(key, move(value));
+    m_map.add(key, std::move(value));
   } else {
-    i->second = move(value);
+    i->second = std::move(value);
     m_map.toBack(i);
   }
 }
diff --git a/source/core/StarLua.cpp b/source/core/StarLua.cpp
index 49d54f3..84e6c82 100644
--- a/source/core/StarLua.cpp
+++ b/source/core/StarLua.cpp
@@ -76,7 +76,7 @@ StringMap<LuaDetail::LuaWrappedFunction> const& LuaCallbacks::callbacks() const
 }
 
 bool LuaContext::containsPath(String path) const {
-  return engine().contextGetPath(handleIndex(), move(path)) != LuaNil;
+  return engine().contextGetPath(handleIndex(), std::move(path)) != LuaNil;
 }
 
 void LuaContext::load(char const* contents, size_t size, char const* name) {
@@ -92,7 +92,7 @@ void LuaContext::load(ByteArray const& contents, String const& name) {
 }
 
 void LuaContext::setRequireFunction(RequireFunction requireFunction) {
-  engine().setContextRequire(handleIndex(), move(requireFunction));
+  engine().setContextRequire(handleIndex(), std::move(requireFunction));
 }
 
 void LuaContext::setCallbacks(String const& tableName, LuaCallbacks const& callbacks) const {
@@ -162,11 +162,11 @@ Maybe<Json> LuaConverter<Json>::to(LuaEngine&, LuaValue const& v) {
 }
 
 LuaValue LuaConverter<JsonObject>::from(LuaEngine& engine, JsonObject v) {
-  return engine.luaFrom<Json>(Json(move(v)));
+  return engine.luaFrom<Json>(Json(std::move(v)));
 }
 
 Maybe<JsonObject> LuaConverter<JsonObject>::to(LuaEngine& engine, LuaValue v) {
-  auto j = engine.luaTo<Json>(move(v));
+  auto j = engine.luaTo<Json>(std::move(v));
   if (j.type() == Json::Type::Object) {
     return j.toObject();
   } else if (j.type() == Json::Type::Array) {
@@ -179,11 +179,11 @@ Maybe<JsonObject> LuaConverter<JsonObject>::to(LuaEngine& engine, LuaValue v) {
 }
 
 LuaValue LuaConverter<JsonArray>::from(LuaEngine& engine, JsonArray v) {
-  return engine.luaFrom<Json>(Json(move(v)));
+  return engine.luaFrom<Json>(Json(std::move(v)));
 }
 
 Maybe<JsonArray> LuaConverter<JsonArray>::to(LuaEngine& engine, LuaValue v) {
-  auto j = engine.luaTo<Json>(move(v));
+  auto j = engine.luaTo<Json>(std::move(v));
   if (j.type() == Json::Type::Array) {
     return j.toArray();
   } else if (j.type() == Json::Type::Object) {
@@ -839,7 +839,7 @@ void LuaEngine::tableIterate(int handleIndex, function<bool(LuaValue key, LuaVal
     LuaValue value = popLuaValue(m_state);
     bool cont = false;
     try {
-      cont = iterator(move(key), move(value));
+      cont = iterator(std::move(key), std::move(value));
     } catch (...) {
       lua_pop(m_state, 2);
       throw;
@@ -881,7 +881,7 @@ void LuaEngine::setContextRequire(int handleIndex, LuaContext::RequireFunction r
   pushHandle(m_state, handleIndex);
 
   auto funcUserdata = (LuaContext::RequireFunction*)lua_newuserdata(m_state, sizeof(LuaContext::RequireFunction));
-  new (funcUserdata) LuaContext::RequireFunction(move(requireFunction));
+  new (funcUserdata) LuaContext::RequireFunction(std::move(requireFunction));
   lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_requireFunctionMetatableRegistryId);
   lua_setmetatable(m_state, -2);
 
@@ -1076,7 +1076,7 @@ LuaFunction LuaEngine::createWrappedFunction(LuaDetail::LuaWrappedFunction funct
   lua_checkstack(m_state, 2);
 
   auto funcUserdata = (LuaDetail::LuaWrappedFunction*)lua_newuserdata(m_state, sizeof(LuaDetail::LuaWrappedFunction));
-  new (funcUserdata) LuaDetail::LuaWrappedFunction(move(function));
+  new (funcUserdata) LuaDetail::LuaWrappedFunction(std::move(function));
 
   lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_wrappedFunctionMetatableRegistryId);
   lua_setmetatable(m_state, -2);
@@ -1400,7 +1400,7 @@ Maybe<Json> LuaDetail::tableToJsonContainer(LuaTable const& table) {
       if (auto i = asInteger(key)) {
         intEntries[*i] = jsonValue.take();
       } else {
-        auto stringKey = table.engine().luaMaybeTo<String>(move(key));
+        auto stringKey = table.engine().luaMaybeTo<String>(std::move(key));
         if (!stringKey) {
           failedConversion = true;
           return false;
@@ -1420,12 +1420,12 @@ Maybe<Json> LuaDetail::tableToJsonContainer(LuaTable const& table) {
   if (interpretAsList) {
     JsonArray list;
     for (auto& p : intEntries)
-      list.set(p.first - 1, move(p.second));
-    return Json(move(list));
+      list.set(p.first - 1, std::move(p.second));
+    return Json(std::move(list));
   } else {
     for (auto& p : intEntries)
-      stringEntries[toString(p.first)] = move(p.second);
-    return Json(move(stringEntries));
+      stringEntries[toString(p.first)] = std::move(p.second);
+    return Json(std::move(stringEntries));
   }
 }
 
diff --git a/source/core/StarLua.hpp b/source/core/StarLua.hpp
index affee9a..d138c8b 100644
--- a/source/core/StarLua.hpp
+++ b/source/core/StarLua.hpp
@@ -856,7 +856,7 @@ struct LuaConverter<std::string> {
   }
 
   static Maybe<std::string> to(LuaEngine& engine, LuaValue v) {
-    return engine.luaTo<String>(move(v)).takeUtf8();
+    return engine.luaTo<String>(std::move(v)).takeUtf8();
   }
 };
 
@@ -887,12 +887,12 @@ struct LuaConverter<Directives> {
 template <>
 struct LuaConverter<LuaString> {
   static LuaValue from(LuaEngine&, LuaString v) {
-    return LuaValue(move(v));
+    return LuaValue(std::move(v));
   }
 
   static Maybe<LuaString> to(LuaEngine& engine, LuaValue v) {
     if (v.is<LuaString>())
-      return LuaString(move(v.get<LuaString>()));
+      return LuaString(std::move(v.get<LuaString>()));
     if (v.is<LuaInt>())
       return engine.createString(toString(v.get<LuaInt>()));
     if (v.is<LuaFloat>())
@@ -909,7 +909,7 @@ struct LuaValueConverter {
 
   static Maybe<T> to(LuaEngine&, LuaValue v) {
     if (auto p = v.ptr<T>()) {
-      return move(*p);
+      return std::move(*p);
     }
     return {};
   }
@@ -967,7 +967,7 @@ struct LuaConverter<Maybe<T>> {
 
   static Maybe<Maybe<T>> to(LuaEngine& engine, LuaValue&& v) {
     if (v != LuaNil) {
-      if (auto conv = engine.luaMaybeTo<T>(move(v)))
+      if (auto conv = engine.luaMaybeTo<T>(std::move(v)))
         return conv;
       else
         return {};
@@ -991,8 +991,8 @@ struct LuaMapConverter {
     T result;
     bool failed = false;
     table->iterate([&result, &failed, &engine](LuaValue key, LuaValue value) {
-        auto contKey = engine.luaMaybeTo<typename T::key_type>(move(key));
-        auto contValue = engine.luaMaybeTo<typename T::mapped_type>(move(value));
+        auto contKey = engine.luaMaybeTo<typename T::key_type>(std::move(key));
+        auto contValue = engine.luaMaybeTo<typename T::mapped_type>(std::move(value));
         if (!contKey || !contValue) {
           failed = true;
           return false;
@@ -1026,7 +1026,7 @@ struct LuaContainerConverter {
           failed = true;
           return false;
         }
-        auto contVal = engine.luaMaybeTo<typename T::value_type>(move(value));
+        auto contVal = engine.luaMaybeTo<typename T::value_type>(std::move(value));
         if (!contVal) {
           failed = true;
           return false;
@@ -1086,7 +1086,7 @@ struct LuaConverter<JsonArray> {
 
 namespace LuaDetail {
   inline LuaHandle::LuaHandle(LuaEnginePtr engine, int handleIndex)
-    : engine(move(engine)), handleIndex(handleIndex) {}
+    : engine(std::move(engine)), handleIndex(handleIndex) {}
 
   inline LuaHandle::~LuaHandle() {
     if (engine)
@@ -1213,7 +1213,7 @@ namespace LuaDetail {
   struct ArgGet {
     static T get(LuaEngine& engine, size_t argc, LuaValue* argv, size_t index) {
       if (index < argc)
-        return engine.luaTo<T>(move(argv[index]));
+        return engine.luaTo<T>(std::move(argv[index]));
       return engine.luaTo<T>(LuaNil);
     }
   };
@@ -1226,7 +1226,7 @@ namespace LuaDetail {
 
       LuaVariadic<T> subargs(argc - index);
       for (size_t i = index; i < argc; ++i)
-        subargs[i - index] = engine.luaTo<T>(move(argv[i]));
+        subargs[i - index] = engine.luaTo<T>(std::move(argv[i]));
       return subargs;
     }
   };
@@ -1235,14 +1235,14 @@ namespace LuaDetail {
   struct FunctionWrapper {
     template <typename Function, size_t... Indexes>
     static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
-      return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
+      return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
         return toWrappedReturn(engine, (Return const&)func(ArgGet<Args>::get(engine, argc, argv, Indexes)...));
       };
     }
 
     template <typename Function>
     static LuaWrappedFunction wrap(Function func) {
-      return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
+      return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
     }
   };
 
@@ -1250,7 +1250,7 @@ namespace LuaDetail {
   struct FunctionWrapper<void, Args...> {
     template <typename Function, size_t... Indexes>
     static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
-      return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
+      return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
         func(ArgGet<Args>::get(engine, argc, argv, Indexes)...);
         return LuaFunctionReturn();
       };
@@ -1258,7 +1258,7 @@ namespace LuaDetail {
 
     template <typename Function>
     static LuaWrappedFunction wrap(Function func) {
-      return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
+      return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
     }
   };
 
@@ -1266,14 +1266,14 @@ namespace LuaDetail {
   struct FunctionWrapper<Return, LuaEngine, Args...> {
     template <typename Function, size_t... Indexes>
     static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
-      return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
+      return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
         return toWrappedReturn(engine, (Return const&)func(engine, ArgGet<Args>::get(engine, argc, argv, Indexes)...));
       };
     }
 
     template <typename Function>
     static LuaWrappedFunction wrap(Function func) {
-      return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
+      return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
     }
   };
 
@@ -1281,7 +1281,7 @@ namespace LuaDetail {
   struct FunctionWrapper<void, LuaEngine, Args...> {
     template <typename Function, size_t... Indexes>
     static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
-      return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
+      return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
         func(engine, ArgGet<Args>::get(engine, argc, argv, Indexes)...);
         return LuaFunctionReturn();
       };
@@ -1289,31 +1289,31 @@ namespace LuaDetail {
 
     template <typename Function>
     static LuaWrappedFunction wrap(Function func) {
-      return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
+      return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
     }
   };
 
   template <typename Return, typename... Args, typename Function>
   LuaWrappedFunction wrapFunctionWithSignature(Function&& func) {
-    return FunctionWrapper<Return, typename std::decay<Args>::type...>::wrap(forward<Function>(func));
+    return FunctionWrapper<Return, typename std::decay<Args>::type...>::wrap(std::forward<Function>(func));
   }
 
   template <typename Return, typename Function, typename... Args>
   LuaWrappedFunction wrapFunctionArgs(Function&& func, VariadicTypedef<Args...> const&) {
-    return wrapFunctionWithSignature<Return, Args...>(forward<Function>(func));
+    return wrapFunctionWithSignature<Return, Args...>(std::forward<Function>(func));
   }
 
   template <typename Function>
   LuaWrappedFunction wrapFunction(Function&& func) {
     return wrapFunctionArgs<typename FunctionTraits<Function>::Return>(
-        forward<Function>(func), typename FunctionTraits<Function>::Args());
+        std::forward<Function>(func), typename FunctionTraits<Function>::Args());
   }
 
   template <typename Return, typename T, typename... Args>
   struct MethodWrapper {
     template <typename Function, size_t... Indexes>
     static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
-      return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) mutable {
+      return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) mutable {
         if (argc == 0)
           throw LuaException("No object argument passed to wrapped method");
         return toWrappedReturn(engine,
@@ -1323,7 +1323,7 @@ namespace LuaDetail {
 
     template <typename Function>
     static LuaWrappedFunction wrap(Function&& func) {
-      return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
+      return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
     }
   };
 
@@ -1331,7 +1331,7 @@ namespace LuaDetail {
   struct MethodWrapper<void, T, Args...> {
     template <typename Function, size_t... Indexes>
     static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
-      return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
+      return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
         if (argc == 0)
           throw LuaException("No object argument passed to wrapped method");
         func(argv[0].get<LuaUserData>().get<T>(), ArgGet<Args>::get(engine, argc - 1, argv + 1, Indexes)...);
@@ -1341,7 +1341,7 @@ namespace LuaDetail {
 
     template <typename Function>
     static LuaWrappedFunction wrap(Function func) {
-      return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
+      return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
     }
   };
 
@@ -1349,7 +1349,7 @@ namespace LuaDetail {
   struct MethodWrapper<Return, T, LuaEngine, Args...> {
     template <typename Function, size_t... Indexes>
     static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
-      return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
+      return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
         if (argc == 0)
           throw LuaException("No object argument passed to wrapped method");
         return toWrappedReturn(
@@ -1360,7 +1360,7 @@ namespace LuaDetail {
 
     template <typename Function>
     static LuaWrappedFunction wrap(Function func) {
-      return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
+      return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
     }
   };
 
@@ -1368,7 +1368,7 @@ namespace LuaDetail {
   struct MethodWrapper<void, T, LuaEngine, Args...> {
     template <typename Function, size_t... Indexes>
     static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
-      return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
+      return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
         if (argc == 0)
           throw LuaException("No object argument passed to wrapped method");
         func(argv[0].get<LuaUserData>().get<T>(), engine, ArgGet<Args>::get(engine, argc - 1, argv + 1, Indexes)...);
@@ -1378,24 +1378,24 @@ namespace LuaDetail {
 
     template <typename Function>
     static LuaWrappedFunction wrap(Function func) {
-      return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
+      return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
     }
   };
 
   template <typename Return, typename... Args, typename Function>
   LuaWrappedFunction wrapMethodWithSignature(Function&& func) {
-    return MethodWrapper<Return, typename std::decay<Args>::type...>::wrap(forward<Function>(func));
+    return MethodWrapper<Return, typename std::decay<Args>::type...>::wrap(std::forward<Function>(func));
   }
 
   template <typename Return, typename Function, typename... Args>
   LuaWrappedFunction wrapMethodArgs(Function&& func, VariadicTypedef<Args...> const&) {
-    return wrapMethodWithSignature<Return, Args...>(forward<Function>(func));
+    return wrapMethodWithSignature<Return, Args...>(std::forward<Function>(func));
   }
 
   template <typename Function>
   LuaWrappedFunction wrapMethod(Function&& func) {
     return wrapMethodArgs<typename FunctionTraits<Function>::Return>(
-        forward<Function>(func), typename FunctionTraits<Function>::Args());
+        std::forward<Function>(func), typename FunctionTraits<Function>::Args());
   }
 
   template <typename Ret, typename... Args>
@@ -1405,8 +1405,8 @@ namespace LuaDetail {
   struct TableIteratorWrapper<bool, LuaEngine&, Key, Value> {
     template <typename Function>
     static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) {
-      return [&engine, func = move(func)](LuaValue key, LuaValue value) -> bool {
-        return func(engine, engine.luaTo<Key>(move(key)), engine.luaTo<Value>(move(value)));
+      return [&engine, func = std::move(func)](LuaValue key, LuaValue value) -> bool {
+        return func(engine, engine.luaTo<Key>(std::move(key)), engine.luaTo<Value>(std::move(value)));
       };
     }
   };
@@ -1415,8 +1415,8 @@ namespace LuaDetail {
   struct TableIteratorWrapper<void, LuaEngine&, Key, Value> {
     template <typename Function>
     static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) {
-      return [&engine, func = move(func)](LuaValue key, LuaValue value) -> bool {
-        func(engine, engine.luaTo<Key>(move(key)), engine.luaTo<Value>(move(value)));
+      return [&engine, func = std::move(func)](LuaValue key, LuaValue value) -> bool {
+        func(engine, engine.luaTo<Key>(std::move(key)), engine.luaTo<Value>(std::move(value)));
         return true;
       };
     }
@@ -1426,8 +1426,8 @@ namespace LuaDetail {
   struct TableIteratorWrapper<bool, Key, Value> {
     template <typename Function>
     static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) {
-      return [&engine, func = move(func)](LuaValue key, LuaValue value) -> bool {
-        return func(engine.luaTo<Key>(move(key)), engine.luaTo<Value>(move(value)));
+      return [&engine, func = std::move(func)](LuaValue key, LuaValue value) -> bool {
+        return func(engine.luaTo<Key>(std::move(key)), engine.luaTo<Value>(std::move(value)));
       };
     }
   };
@@ -1436,8 +1436,8 @@ namespace LuaDetail {
   struct TableIteratorWrapper<void, Key, Value> {
     template <typename Function>
     static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) {
-      return [&engine, func = move(func)](LuaValue key, LuaValue value) -> bool {
-        func(engine.luaTo<Key>(move(key)), engine.luaTo<Value>(move(value)));
+      return [&engine, func = std::move(func)](LuaValue key, LuaValue value) -> bool {
+        func(engine.luaTo<Key>(std::move(key)), engine.luaTo<Value>(std::move(value)));
         return true;
       };
     }
@@ -1445,19 +1445,19 @@ namespace LuaDetail {
 
   template <typename Return, typename... Args, typename Function>
   function<bool(LuaValue, LuaValue)> wrapTableIteratorWithSignature(LuaEngine& engine, Function&& func) {
-    return TableIteratorWrapper<Return, typename std::decay<Args>::type...>::wrap(engine, forward<Function>(func));
+    return TableIteratorWrapper<Return, typename std::decay<Args>::type...>::wrap(engine, std::forward<Function>(func));
   }
 
   template <typename Return, typename Function, typename... Args>
   function<bool(LuaValue, LuaValue)> wrapTableIteratorArgs(
       LuaEngine& engine, Function&& func, VariadicTypedef<Args...> const&) {
-    return wrapTableIteratorWithSignature<Return, Args...>(engine, forward<Function>(func));
+    return wrapTableIteratorWithSignature<Return, Args...>(engine, std::forward<Function>(func));
   }
 
   template <typename Function>
   function<bool(LuaValue, LuaValue)> wrapTableIterator(LuaEngine& engine, Function&& func) {
     return wrapTableIteratorArgs<typename FunctionTraits<Function>::Return>(
-        engine, forward<Function>(func), typename FunctionTraits<Function>::Args());
+        engine, std::forward<Function>(func), typename FunctionTraits<Function>::Args());
   }
 
   // Like lua_setfield / lua_getfield but raw.
@@ -1520,7 +1520,7 @@ LuaVariadic<typename std::decay<Container>::type::value_type> luaUnpack(Containe
   LuaVariadic<typename std::decay<Container>::type::value_type> ret;
   if (std::is_rvalue_reference<Container&&>::value) {
     for (auto& e : c)
-      ret.append(move(e));
+      ret.append(std::move(e));
   } else {
     for (auto const& e : c)
       ret.append(e);
@@ -1535,7 +1535,7 @@ LuaTupleReturn<Types...>::LuaTupleReturn(Types const&... args)
 template <typename... Types>
 template <typename... UTypes>
 LuaTupleReturn<Types...>::LuaTupleReturn(UTypes&&... args)
-  : Base(move(args)...) {}
+  : Base(std::move(args)...) {}
 
 template <typename... Types>
 template <typename... UTypes>
@@ -1548,7 +1548,7 @@ LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn const& rhs)
 
 template <typename... Types>
 LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn&& rhs)
-  : Base(move(rhs)) {}
+  : Base(std::move(rhs)) {}
 
 template <typename... Types>
 template <typename... UTypes>
@@ -1558,7 +1558,7 @@ LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn<UTypes...> const& rhs)
 template <typename... Types>
 template <typename... UTypes>
 LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn<UTypes...>&& rhs)
-  : Base(move(rhs)) {}
+  : Base(std::move(rhs)) {}
 
 template <typename... Types>
 LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn const& rhs) {
@@ -1568,7 +1568,7 @@ LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn con
 
 template <typename... Types>
 LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn&& rhs) {
-  Base::operator=(move(rhs));
+  Base::operator=(std::move(rhs));
   return *this;
 }
 
@@ -1582,7 +1582,7 @@ LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn<UTy
 template <typename... Types>
 template <typename... UTypes>
 LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn<UTypes...>&& rhs) {
-  Base::operator=((tuple<UTypes...> && )move(rhs));
+  Base::operator=((tuple<UTypes...> && )std::move(rhs));
   return *this;
 }
 
@@ -1593,10 +1593,10 @@ LuaTupleReturn<Types&...> luaTie(Types&... args) {
 
 template <typename... Types>
 LuaTupleReturn<typename std::decay<Types>::type...> luaTupleReturn(Types&&... args) {
-  return LuaTupleReturn<typename std::decay<Types>::type...>(forward<Types>(args)...);
+  return LuaTupleReturn<typename std::decay<Types>::type...>(std::forward<Types>(args)...);
 }
 
-inline LuaReference::LuaReference(LuaDetail::LuaHandle handle) : m_handle(move(handle)) {}
+inline LuaReference::LuaReference(LuaDetail::LuaHandle handle) : m_handle(std::move(handle)) {}
 
 inline bool LuaReference::operator==(LuaReference const& rhs) const {
   return tie(m_handle.engine, m_handle.handleIndex) == tie(rhs.m_handle.engine, rhs.m_handle.handleIndex);
@@ -1688,7 +1688,7 @@ inline bool operator!=(String const& s1, LuaString const& s2) {
 
 template <typename T, typename K>
 T LuaTable::get(K key) const {
-  return engine().luaTo<T>(engine().tableGet(false, handleIndex(), engine().luaFrom(move(key))));
+  return engine().luaTo<T>(engine().tableGet(false, handleIndex(), engine().luaFrom(std::move(key))));
 }
 
 template <typename T>
@@ -1698,17 +1698,17 @@ T LuaTable::get(char const* key) const {
 
 template <typename T, typename K>
 void LuaTable::set(K key, T value) const {
-  engine().tableSet(false, handleIndex(), engine().luaFrom(move(key)), engine().luaFrom(move(value)));
+  engine().tableSet(false, handleIndex(), engine().luaFrom(std::move(key)), engine().luaFrom(std::move(value)));
 }
 
 template <typename T>
 void LuaTable::set(char const* key, T value) const {
-  engine().tableSet(false, handleIndex(), key, engine().luaFrom(move(value)));
+  engine().tableSet(false, handleIndex(), key, engine().luaFrom(std::move(value)));
 }
 
 template <typename K>
 bool LuaTable::contains(K key) const {
-  return engine().tableGet(false, handleIndex(), engine().luaFrom(move(key))) != LuaNil;
+  return engine().tableGet(false, handleIndex(), engine().luaFrom(std::move(key))) != LuaNil;
 }
 
 template <typename K>
@@ -1718,12 +1718,12 @@ void LuaTable::remove(K key) const {
 
 template <typename Function>
 void LuaTable::iterate(Function&& function) const {
-  return engine().tableIterate(handleIndex(), LuaDetail::wrapTableIterator(engine(), forward<Function>(function)));
+  return engine().tableIterate(handleIndex(), LuaDetail::wrapTableIterator(engine(), std::forward<Function>(function)));
 }
 
 template <typename Return, typename... Args, typename Function>
 void LuaTable::iterateWithSignature(Function&& func) const {
-  return engine().tableIterate(handleIndex(), LuaDetail::wrapTableIteratorWithSignature<Return, Args...>(engine(), forward<Function>(func)));
+  return engine().tableIterate(handleIndex(), LuaDetail::wrapTableIteratorWithSignature<Return, Args...>(engine(), std::forward<Function>(func)));
 }
 
 template <typename T, typename K>
@@ -1779,27 +1779,27 @@ T& LuaUserData::get() const {
 
 template <typename Function>
 void LuaCallbacks::registerCallback(String name, Function&& func) {
-  if (!m_callbacks.insert(name, LuaDetail::wrapFunction(forward<Function>(func))).second)
+  if (!m_callbacks.insert(name, LuaDetail::wrapFunction(std::forward<Function>(func))).second)
     throw LuaException::format("Lua callback '{}' was registered twice", name);
 }
 
 template <typename Return, typename... Args, typename Function>
 void LuaCallbacks::registerCallbackWithSignature(String name, Function&& func) {
-  if (!m_callbacks.insert(name, LuaDetail::wrapFunctionWithSignature<Return, Args...>(forward<Function>(func))).second)
+  if (!m_callbacks.insert(name, LuaDetail::wrapFunctionWithSignature<Return, Args...>(std::forward<Function>(func))).second)
     throw LuaException::format("Lua callback '{}' was registered twice", name);
 }
 
 template <typename T>
 template <typename Function>
 void LuaMethods<T>::registerMethod(String name, Function&& func) {
-  if (!m_methods.insert(name, LuaDetail::wrapMethod(forward<Function>(move(func)))).second)
+  if (!m_methods.insert(name, LuaDetail::wrapMethod(std::forward<Function>(std::move(func)))).second)
     throw LuaException::format("Lua method '{}' was registered twice", name);
 }
 
 template <typename T>
 template <typename Return, typename... Args, typename Function>
 void LuaMethods<T>::registerMethodWithSignature(String name, Function&& func) {
-  if (!m_methods.insert(name, LuaDetail::wrapMethodWithSignature<Return, Args...>(forward<Function>(move(func))))
+  if (!m_methods.insert(name, LuaDetail::wrapMethodWithSignature<Return, Args...>(std::forward<Function>(std::move(func))))
            .second)
     throw LuaException::format("Lua method '{}' was registered twice", name);
 }
@@ -1811,12 +1811,12 @@ StringMap<LuaDetail::LuaWrappedFunction> const& LuaMethods<T>::methods() const {
 
 template <typename T>
 T LuaContext::getPath(String path) const {
-  return engine().luaTo<T>(engine().contextGetPath(handleIndex(), move(path)));
+  return engine().luaTo<T>(engine().contextGetPath(handleIndex(), std::move(path)));
 }
 
 template <typename T>
 void LuaContext::setPath(String key, T value) {
-  engine().contextSetPath(handleIndex(), move(key), engine().luaFrom<T>(move(value)));
+  engine().contextSetPath(handleIndex(), std::move(key), engine().luaFrom<T>(std::move(value)));
 }
 
 template <typename Ret>
@@ -1834,7 +1834,7 @@ Ret LuaContext::invokePath(String const& key, Args const&... args) const {
 
 template <typename T>
 LuaValue LuaContext::luaFrom(T&& t) {
-  return engine().luaFrom(forward<T>(t));
+  return engine().luaFrom(std::forward<T>(t));
 }
 
 template <typename T>
@@ -1844,7 +1844,7 @@ LuaValue LuaContext::luaFrom(T const& t) {
 
 template <typename T>
 Maybe<T> LuaContext::luaMaybeTo(LuaValue&& v) {
-  return engine().luaFrom(move(v));
+  return engine().luaFrom(std::move(v));
 }
 
 template <typename T>
@@ -1854,7 +1854,7 @@ Maybe<T> LuaContext::luaMaybeTo(LuaValue const& v) {
 
 template <typename T>
 T LuaContext::luaTo(LuaValue&& v) {
-  return engine().luaTo<T>(move(v));
+  return engine().luaTo<T>(std::move(v));
 }
 
 template <typename T>
@@ -1874,17 +1874,17 @@ LuaTable LuaContext::createArrayTable(Container const& array) {
 
 template <typename Function>
 LuaFunction LuaContext::createFunction(Function&& func) {
-  return engine().createFunction(forward<Function>(func));
+  return engine().createFunction(std::forward<Function>(func));
 }
 
 template <typename Return, typename... Args, typename Function>
 LuaFunction LuaContext::createFunctionWithSignature(Function&& func) {
-  return engine().createFunctionWithSignature<Return, Args...>(forward<Function>(func));
+  return engine().createFunctionWithSignature<Return, Args...>(std::forward<Function>(func));
 }
 
 template <typename T>
 LuaUserData LuaContext::createUserData(T t) {
-  return engine().createUserData(move(t));
+  return engine().createUserData(std::move(t));
 }
 
 template <typename T>
@@ -1894,7 +1894,7 @@ LuaMethods<T> LuaUserDataMethods<T>::make() {
 
 template <typename T>
 LuaValue LuaUserDataConverter<T>::from(LuaEngine& engine, T t) {
-  return engine.createUserData(move(t));
+  return engine.createUserData(std::move(t));
 }
 
 template <typename T>
@@ -1908,7 +1908,7 @@ Maybe<T> LuaUserDataConverter<T>::to(LuaEngine&, LuaValue const& v) {
 
 template <typename T>
 LuaValue LuaEngine::luaFrom(T&& t) {
-  return LuaConverter<typename std::decay<T>::type>::from(*this, forward<T>(t));
+  return LuaConverter<typename std::decay<T>::type>::from(*this, std::forward<T>(t));
 }
 
 template <typename T>
@@ -1918,7 +1918,7 @@ LuaValue LuaEngine::luaFrom(T const& t) {
 
 template <typename T>
 Maybe<T> LuaEngine::luaMaybeTo(LuaValue&& v) {
-  return LuaConverter<T>::to(*this, move(v));
+  return LuaConverter<T>::to(*this, std::move(v));
 }
 
 template <typename T>
@@ -1928,7 +1928,7 @@ Maybe<T> LuaEngine::luaMaybeTo(LuaValue const& v) {
 
 template <typename T>
 T LuaEngine::luaTo(LuaValue&& v) {
-  if (auto res = luaMaybeTo<T>(move(v)))
+  if (auto res = luaMaybeTo<T>(std::move(v)))
     return res.take();
   throw LuaConversionException::format("Error converting LuaValue to type '{}'", typeid(T).name());
 }
@@ -1961,12 +1961,12 @@ LuaTable LuaEngine::createArrayTable(Container const& array) {
 
 template <typename Function>
 LuaFunction LuaEngine::createFunction(Function&& func) {
-  return createWrappedFunction(LuaDetail::wrapFunction(forward<Function>(func)));
+  return createWrappedFunction(LuaDetail::wrapFunction(std::forward<Function>(func)));
 }
 
 template <typename Return, typename... Args, typename Function>
 LuaFunction LuaEngine::createFunctionWithSignature(Function&& func) {
-  return createWrappedFunction(LuaDetail::wrapFunctionWithSignature<Return, Args...>(forward<Function>(func)));
+  return createWrappedFunction(LuaDetail::wrapFunctionWithSignature<Return, Args...>(std::forward<Function>(func)));
 }
 
 template <typename... Args>
@@ -2026,7 +2026,7 @@ Maybe<LuaDetail::LuaFunctionReturn> LuaEngine::resumeThread(int handleIndex, Arg
     LuaVariadic<LuaValue> ret(returnValues);
     for (int i = returnValues - 1; i >= 0; --i)
       ret[i] = popLuaValue(threadState);
-    return LuaDetail::LuaFunctionReturn(move(ret));
+    return LuaDetail::LuaFunctionReturn(std::move(ret));
   }
 }
 
@@ -2071,7 +2071,7 @@ LuaUserData LuaEngine::createUserData(T t) {
 
   lua_checkstack(m_state, 2);
 
-  new (lua_newuserdata(m_state, sizeof(T))) T(move(t));
+  new (lua_newuserdata(m_state, sizeof(T))) T(std::move(t));
 
   lua_rawgeti(m_state, LUA_REGISTRYINDEX, typeMetatable);
   lua_setmetatable(m_state, -2);
@@ -2083,7 +2083,7 @@ template <typename T, typename K>
 T LuaEngine::getGlobal(K key) {
   lua_checkstack(m_state, 1);
   lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_scriptDefaultEnvRegistryId);
-  pushLuaValue(m_state, luaFrom(move(key)));
+  pushLuaValue(m_state, luaFrom(std::move(key)));
   lua_rawget(m_state, -2);
 
   LuaValue v = popLuaValue(m_state);
@@ -2109,8 +2109,8 @@ void LuaEngine::setGlobal(K key, T value) {
   lua_checkstack(m_state, 1);
 
   lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_scriptDefaultEnvRegistryId);
-  pushLuaValue(m_state, luaFrom(move(key)));
-  pushLuaValue(m_state, luaFrom(move(value)));
+  pushLuaValue(m_state, luaFrom(std::move(key)));
+  pushLuaValue(m_state, luaFrom(std::move(value)));
 
   lua_rawset(m_state, -3);
   lua_pop(m_state, 1);
diff --git a/source/core/StarLuaConverters.hpp b/source/core/StarLuaConverters.hpp
index f476d2e..277f691 100644
--- a/source/core/StarLuaConverters.hpp
+++ b/source/core/StarLuaConverters.hpp
@@ -33,8 +33,8 @@ template <typename T1, typename T2>
 struct LuaConverter<pair<T1, T2>> {
   static LuaValue from(LuaEngine& engine, pair<T1, T2>&& v) {
     auto t = engine.createTable();
-    t.set(1, move(v.first));
-    t.set(2, move(v.second));
+    t.set(1, std::move(v.first));
+    t.set(2, std::move(v.second));
     return t;
   }
 
@@ -46,7 +46,7 @@ struct LuaConverter<pair<T1, T2>> {
   }
 
   static Maybe<pair<T1, T2>> to(LuaEngine& engine, LuaValue const& v) {
-    if (auto table = engine.luaMaybeTo<LuaTable>(move(v))) {
+    if (auto table = engine.luaMaybeTo<LuaTable>(std::move(v))) {
       auto p1 = engine.luaMaybeTo<T1>(table->get(1));
       auto p2 = engine.luaMaybeTo<T2>(table->get(2));
       if (p1 && p2)
@@ -173,7 +173,7 @@ struct LuaConverter<Variant<FirstType, RestTypes...>> {
   }
 
   static LuaValue from(LuaEngine& engine, Variant<FirstType, RestTypes...>&& variant) {
-    return variant.call([&engine](auto& a) { return luaFrom(engine, move(a)); });
+    return variant.call([&engine](auto& a) { return luaFrom(engine, std::move(a)); });
   }
 
   static Maybe<Variant<FirstType, RestTypes...>> to(LuaEngine& engine, LuaValue const& v) {
@@ -194,7 +194,7 @@ struct LuaConverter<Variant<FirstType, RestTypes...>> {
   }
 
   static Maybe<Variant<FirstType, RestTypes...>> to(LuaEngine& engine, LuaValue&& v) {
-    return checkTypeTo<FirstType, RestTypes...>(engine, move(v));
+    return checkTypeTo<FirstType, RestTypes...>(engine, std::move(v));
   }
 
   template <typename CheckType1, typename CheckType2, typename... CheckTypeRest>
@@ -202,12 +202,12 @@ struct LuaConverter<Variant<FirstType, RestTypes...>> {
     if (auto t1 = engine.luaMaybeTo<CheckType1>(v))
       return t1;
     else
-      return checkTypeTo<CheckType2, CheckTypeRest...>(engine, move(v));
+      return checkTypeTo<CheckType2, CheckTypeRest...>(engine, std::move(v));
   }
 
   template <typename Type>
   static Maybe<Variant<FirstType, RestTypes...>> checkTypeTo(LuaEngine& engine, LuaValue&& v) {
-    return engine.luaMaybeTo<Type>(move(v));
+    return engine.luaMaybeTo<Type>(std::move(v));
   }
 };
 
@@ -226,7 +226,7 @@ struct LuaConverter<MVariant<Types...>> {
   static LuaValue from(LuaEngine& engine, MVariant<Types...>&& variant) {
     LuaValue value;
     variant.call([&value, &engine](auto& a) {
-        value = luaFrom(engine, move(a));
+        value = luaFrom(engine, std::move(a));
       });
     return value;
   }
@@ -253,7 +253,7 @@ struct LuaConverter<MVariant<Types...>> {
   static Maybe<MVariant<Types...>> to(LuaEngine& engine, LuaValue&& v) {
     if (v == LuaNil)
       return MVariant<Types...>();
-    return checkTypeTo<Types...>(engine, move(v));
+    return checkTypeTo<Types...>(engine, std::move(v));
   }
 
   template <typename CheckType1, typename CheckType2, typename... CheckTypeRest>
@@ -261,12 +261,12 @@ struct LuaConverter<MVariant<Types...>> {
     if (auto t1 = engine.luaMaybeTo<CheckType1>(v))
       return t1;
     else
-      return checkTypeTo<CheckType2, CheckTypeRest...>(engine, move(v));
+      return checkTypeTo<CheckType2, CheckTypeRest...>(engine, std::move(v));
   }
 
   template <typename CheckType>
   static Maybe<MVariant<Types...>> checkTypeTo(LuaEngine& engine, LuaValue&& v) {
-    return engine.luaMaybeTo<CheckType>(move(v));
+    return engine.luaMaybeTo<CheckType>(std::move(v));
   }
 
 };
diff --git a/source/core/StarMap.hpp b/source/core/StarMap.hpp
index cf9c260..187f4cf 100644
--- a/source/core/StarMap.hpp
+++ b/source/core/StarMap.hpp
@@ -172,7 +172,7 @@ auto MapMixin<BaseMap>::maybeTake(key_type const& k) -> Maybe<mapped_type> {
   if (i != Base::end()) {
     mapped_type v = std::move(i->second);
     Base::erase(i);
-    return move(v);
+    return v;
   }
 
   return {};
@@ -198,7 +198,7 @@ template <typename BaseMap>
 auto MapMixin<BaseMap>::value(key_type const& k, mapped_type d) const -> mapped_type {
   const_iterator i = Base::find(k);
   if (i == Base::end())
-    return std::move(d);
+    return d;
   else
     return i->second;
 }
@@ -260,12 +260,12 @@ auto MapMixin<BaseMap>::hasValue(mapped_type const& v) const -> bool {
 
 template <typename BaseMap>
 auto MapMixin<BaseMap>::insert(key_type k, mapped_type v) -> pair<iterator, bool> {
-  return Base::insert(value_type(move(k), move(v)));
+  return Base::insert(value_type(std::move(k), std::move(v)));
 }
 
 template <typename BaseMap>
 auto MapMixin<BaseMap>::add(key_type k, mapped_type v) -> mapped_type& {
-  auto pair = Base::insert(value_type(move(k), move(v)));
+  auto pair = Base::insert(value_type(std::move(k), std::move(v)));
   if (!pair.second)
     throw MapException(strf("Entry with key '{}' already present.", outputAny(k)));
   else
@@ -276,10 +276,10 @@ template <typename BaseMap>
 auto MapMixin<BaseMap>::set(key_type k, mapped_type v) -> mapped_type& {
   auto i = Base::find(k);
   if (i != Base::end()) {
-    i->second = move(v);
+    i->second = std::move(v);
     return i->second;
   } else {
-    return Base::insert(value_type(move(k), move(v))).first->second;
+    return Base::insert(value_type(std::move(k), std::move(v))).first->second;
   }
 }
 
diff --git a/source/core/StarMaybe.hpp b/source/core/StarMaybe.hpp
index 2b2b70d..2c53bcb 100644
--- a/source/core/StarMaybe.hpp
+++ b/source/core/StarMaybe.hpp
@@ -118,7 +118,7 @@ Maybe<T>::Maybe(T const& t)
 template <typename T>
 Maybe<T>::Maybe(T&& t)
   : Maybe() {
-  new (&m_data) T(forward<T>(t));
+  new (&m_data) T(std::forward<T>(t));
   m_initialized = true;
 }
 
@@ -135,7 +135,7 @@ template <typename T>
 Maybe<T>::Maybe(Maybe&& rhs)
   : Maybe() {
   if (rhs.m_initialized) {
-    new (&m_data) T(move(rhs.m_data));
+    new (&m_data) T(std::move(rhs.m_data));
     m_initialized = true;
     rhs.reset();
   }
@@ -308,7 +308,7 @@ T Maybe<T>::take() {
   if (!m_initialized)
     throw InvalidMaybeAccessException();
 
-  T val(move(m_data));
+  T val(std::move(m_data));
 
   reset();
 
@@ -318,7 +318,7 @@ T Maybe<T>::take() {
 template <typename T>
 bool Maybe<T>::put(T& t) {
   if (m_initialized) {
-    t = move(m_data);
+    t = std::move(m_data);
 
     reset();
 
@@ -335,7 +335,7 @@ void Maybe<T>::set(T const& t) {
 
 template <typename T>
 void Maybe<T>::set(T&& t) {
-  emplace(forward<T>(t));
+  emplace(std::forward<T>(t));
 }
 
 template <typename T>
@@ -343,7 +343,7 @@ template <typename... Args>
 void Maybe<T>::emplace(Args&&... t) {
   reset();
 
-  new (&m_data) T(forward<Args>(t)...);
+  new (&m_data) T(std::forward<Args>(t)...);
   m_initialized = true;
 }
 
diff --git a/source/core/StarMultiArray.hpp b/source/core/StarMultiArray.hpp
index 3668c8a..bb33490 100644
--- a/source/core/StarMultiArray.hpp
+++ b/source/core/StarMultiArray.hpp
@@ -326,14 +326,14 @@ void MultiArray<Element, Rank>::set(IndexArray const& index, Element element) {
       throw MultiArrayException(strf("Out of bounds on MultiArray::set({})", index));
   }
 
-  m_data[storageIndex(index)] = move(element);
+  m_data[storageIndex(index)] = std::move(element);
 }
 
 template <typename Element, size_t Rank>
 Element MultiArray<Element, Rank>::get(IndexArray const& index, Element def) {
   for (size_t i = Rank; i != 0; --i) {
     if (index[i - 1] >= m_shape[i - 1])
-      return move(def);
+      return std::move(def);
   }
 
   return m_data[storageIndex(index)];
@@ -346,7 +346,7 @@ void MultiArray<Element, Rank>::setResize(IndexArray const& index, Element eleme
     newShape[i] = std::max(m_shape[i], index[i] + 1);
   resize(newShape);
 
-  m_data[storageIndex(index)] = move(element);
+  m_data[storageIndex(index)] = std::move(element);
 }
 
 template <typename Element, size_t Rank>
@@ -369,26 +369,26 @@ template <typename Element, size_t Rank>
 template <typename OpType>
 void MultiArray<Element, Rank>::forEach(IndexArray const& min, SizeArray const& size, OpType&& op) {
   IndexArray index;
-  subForEach(min, size, forward<OpType>(op), index, 0, 0);
+  subForEach(min, size, std::forward<OpType>(op), index, 0, 0);
 }
 
 template <typename Element, size_t Rank>
 template <typename OpType>
 void MultiArray<Element, Rank>::forEach(IndexArray const& min, SizeArray const& size, OpType&& op) const {
   IndexArray index;
-  subForEach(min, size, forward<OpType>(op), index, 0, 0);
+  subForEach(min, size, std::forward<OpType>(op), index, 0, 0);
 }
 
 template <typename Element, size_t Rank>
 template <typename OpType>
 void MultiArray<Element, Rank>::forEach(OpType&& op) {
-  forEach(IndexArray::filled(0), size(), forward<OpType>(op));
+  forEach(IndexArray::filled(0), size(), std::forward<OpType>(op));
 }
 
 template <typename Element, size_t Rank>
 template <typename OpType>
 void MultiArray<Element, Rank>::forEach(OpType&& op) const {
-  forEach(IndexArray::filled(0), size(), forward<OpType>(op));
+  forEach(IndexArray::filled(0), size(), std::forward<OpType>(op));
 }
 
 template <typename Element, size_t Rank>
@@ -461,7 +461,7 @@ void MultiArray<Element, Rank>::subForEach(IndexArray const& min, SizeArray cons
     if (dim == Rank - 1)
       op(index, m_data[offset + i]);
     else
-      subForEach(min, size, forward<OpType>(op), index, (offset + i) * m_shape[dim + 1], dim + 1);
+      subForEach(min, size, std::forward<OpType>(op), index, (offset + i) * m_shape[dim + 1], dim + 1);
   }
 }
 
@@ -475,7 +475,7 @@ void MultiArray<Element, Rank>::subForEach(IndexArray const& min, SizeArray cons
     if (dim == Rank - 1)
       op(index, m_data[offset + i]);
     else
-      subForEach(min, size, forward<OpType>(op), index, (offset + i) * m_shape[dim + 1], dim + 1);
+      subForEach(min, size, std::forward<OpType>(op), index, (offset + i) * m_shape[dim + 1], dim + 1);
   }
 }
 
diff --git a/source/core/StarNetElementBasicFields.hpp b/source/core/StarNetElementBasicFields.hpp
index f0939a7..2d9f8e5 100644
--- a/source/core/StarNetElementBasicFields.hpp
+++ b/source/core/StarNetElementBasicFields.hpp
@@ -155,7 +155,7 @@ void NetElementBasicField<T>::set(T const& value) {
 
 template <typename T>
 void NetElementBasicField<T>::push(T value) {
-  m_value = move(value);
+  m_value = std::move(value);
   updated();
   m_latestUpdateVersion = m_netVersion ? m_netVersion->current() : 0;
   if (m_pendingInterpolatedValues)
@@ -251,14 +251,14 @@ void NetElementBasicField<T>::readNetDelta(DataStream& ds, float interpolationTi
     // case, this is an error or the step tracking is wildly off, so just clear
     // any other incoming values.
     if (interpolationTime > 0.0f && (m_pendingInterpolatedValues->empty() || interpolationTime >= m_pendingInterpolatedValues->last().first)) {
-      m_pendingInterpolatedValues->append({interpolationTime, move(t)});
+      m_pendingInterpolatedValues->append({interpolationTime, std::move(t)});
     } else {
-      m_value = move(t);
+      m_value = std::move(t);
       m_pendingInterpolatedValues->clear();
       updated();
     }
   } else {
-    m_value = move(t);
+    m_value = std::move(t);
     updated();
   }
 }
@@ -314,7 +314,7 @@ NetElementData<T>::NetElementData()
 
 template <typename T>
 NetElementData<T>::NetElementData(function<void(DataStream&, T&)> reader, function<void(DataStream&, T const&)> writer)
-  : m_reader(move(reader)), m_writer(move(writer)) {}
+  : m_reader(std::move(reader)), m_writer(std::move(writer)) {}
 
 template <typename T>
 void NetElementData<T>::readData(DataStream& ds, T& v) const {
diff --git a/source/core/StarNetElementContainers.hpp b/source/core/StarNetElementContainers.hpp
index 2127076..b48755d 100644
--- a/source/core/StarNetElementContainers.hpp
+++ b/source/core/StarNetElementContainers.hpp
@@ -124,7 +124,7 @@ void NetElementMapWrapper<BaseMap>::initNetVersion(NetElementVersion const* vers
   m_changeDataLastVersion = 0;
 
   for (auto& change : Star::take(m_pendingChangeData))
-    applyChange(move(change.second));
+    applyChange(std::move(change.second));
 
   addChangeData(ClearChange());
   for (auto const& p : *this)
@@ -140,7 +140,7 @@ template <typename BaseMap>
 void NetElementMapWrapper<BaseMap>::disableNetInterpolation() {
   m_interpolationEnabled = false;
   for (auto& change : Star::take(m_pendingChangeData))
-    applyChange(move(change.second));
+    applyChange(std::move(change.second));
 }
 
 template <typename BaseMap>
@@ -175,7 +175,7 @@ void NetElementMapWrapper<BaseMap>::netLoad(DataStream& ds) {
   for (uint64_t i = 0; i < count; ++i) {
     auto change = readChange(ds);
     addChangeData(change);
-    applyChange(move(change));
+    applyChange(std::move(change));
   }
 
   m_updated = true;
@@ -219,9 +219,9 @@ void NetElementMapWrapper<BaseMap>::readNetDelta(DataStream& ds, float interpola
       addChangeData(change);
 
       if (m_interpolationEnabled && interpolationTime > 0.0f)
-        addPendingChangeData(move(change), interpolationTime);
+        addPendingChangeData(std::move(change), interpolationTime);
       else
-        applyChange(move(change));
+        applyChange(std::move(change));
     } else {
       throw IOException("Improper delta code received in NetElementMapWrapper::readNetDelta");
     }
@@ -252,7 +252,7 @@ template <typename BaseMap>
 auto NetElementMapWrapper<BaseMap>::insert(value_type v) -> pair<const_iterator, bool> {
   auto res = BaseMap::insert(v);
   if (res.second) {
-    addChangeData(SetChange{move(v.first), move(v.second)});
+    addChangeData(SetChange{std::move(v.first), std::move(v.second)});
     m_updated = true;
   }
   return res;
@@ -260,12 +260,12 @@ auto NetElementMapWrapper<BaseMap>::insert(value_type v) -> pair<const_iterator,
 
 template <typename BaseMap>
 auto NetElementMapWrapper<BaseMap>::insert(key_type k, mapped_type v) -> pair<const_iterator, bool> {
-  return insert(value_type(move(k), move(v)));
+  return insert(value_type(std::move(k), std::move(v)));
 }
 
 template <typename BaseMap>
 void NetElementMapWrapper<BaseMap>::add(key_type k, mapped_type v) {
-  if (!insert(value_type(move(k), move(v))).second)
+  if (!insert(value_type(std::move(k), std::move(v))).second)
     throw MapException::format("Entry with key '{}' already present.", outputAny(k));
 }
 
@@ -274,13 +274,13 @@ void NetElementMapWrapper<BaseMap>::set(key_type k, mapped_type v) {
   auto i = BaseMap::find(k);
   if (i != BaseMap::end()) {
     if (!(i->second == v)) {
-      addChangeData(SetChange{move(k), v});
-      i->second = move(v);
+      addChangeData(SetChange{std::move(k), v});
+      i->second = std::move(v);
       m_updated = true;
     }
   } else {
     addChangeData(SetChange{k, v});
-    BaseMap::insert(value_type(move(k), move(v)));
+    BaseMap::insert(value_type(std::move(k), std::move(v)));
     m_updated = true;
   }
 }
@@ -289,11 +289,11 @@ template <typename BaseMap>
 void NetElementMapWrapper<BaseMap>::push(key_type k, mapped_type v) {
   auto i = BaseMap::find(k);
   if (i != BaseMap::end()) {
-    addChangeData(SetChange(move(k), v));
-    i->second = move(v);
+    addChangeData(SetChange(std::move(k), v));
+    i->second = std::move(v);
   } else {
     addChangeData(SetChange(k, v));
-    BaseMap::insert(value_type(move(k), move(v)));
+    BaseMap::insert(value_type(std::move(k), std::move(v)));
   }
   m_updated = true;
 }
@@ -322,7 +322,7 @@ auto NetElementMapWrapper<BaseMap>::take(key_type const& k) -> mapped_type {
   auto i = BaseMap::find(k);
   if (i == BaseMap::end())
     throw MapException::format("Key '{}' not found in Map::take()", outputAny(k));
-  auto m = move(i->second);
+  auto m = std::move(i->second);
   erase(i);
   return m;
 }
@@ -332,9 +332,9 @@ auto NetElementMapWrapper<BaseMap>::maybeTake(key_type const& k) -> Maybe<mapped
   auto i = BaseMap::find(k);
   if (i == BaseMap::end())
     return {};
-  auto m = move(i->second);
+  auto m = std::move(i->second);
   erase(i);
-  return Maybe<mapped_type>(move(m));
+  return Maybe<mapped_type>(std::move(m));
 }
 
 template <typename BaseMap>
@@ -368,7 +368,7 @@ void NetElementMapWrapper<BaseMap>::reset(BaseMap values) {
     }
   }
 
-  BaseMap::operator=(move(values));
+  BaseMap::operator=(std::move(values));
 }
 
 template <typename BaseMap>
@@ -420,7 +420,7 @@ void NetElementMapWrapper<BaseMap>::addChangeData(ElementChange change) {
   uint64_t currentVersion = m_netVersion ? m_netVersion->current() : 0;
   starAssert(m_changeData.empty() || m_changeData.last().first <= currentVersion);
 
-  m_changeData.append({currentVersion, move(change)});
+  m_changeData.append({currentVersion, std::move(change)});
 
   m_changeDataLastVersion = max<int64_t>((int64_t)currentVersion - MaxChangeDataVersions, 0);
   while (!m_changeData.empty() && m_changeData.first().first < m_changeDataLastVersion)
@@ -431,17 +431,17 @@ template <typename BaseMap>
 void NetElementMapWrapper<BaseMap>::addPendingChangeData(ElementChange change, float interpolationTime) {
   if (!m_pendingChangeData.empty() && interpolationTime < m_pendingChangeData.last().first) {
     for (auto& change : Star::take(m_pendingChangeData))
-      applyChange(move(change.second));
+      applyChange(std::move(change.second));
   }
-  m_pendingChangeData.append({interpolationTime, move(change)});
+  m_pendingChangeData.append({interpolationTime, std::move(change)});
 }
 
 template <typename BaseMap>
 void NetElementMapWrapper<BaseMap>::applyChange(ElementChange change) {
   if (auto set = change.template ptr<SetChange>())
-    BaseMap::set(move(set->key), move(set->value));
+    BaseMap::set(std::move(set->key), std::move(set->value));
   else if (auto remove = change.template ptr<RemoveChange>())
-    BaseMap::remove(move(remove->key));
+    BaseMap::remove(std::move(remove->key));
   else
     BaseMap::clear();
   m_updated = true;
diff --git a/source/core/StarNetElementDynamicGroup.hpp b/source/core/StarNetElementDynamicGroup.hpp
index 5d34c8d..75d11c8 100644
--- a/source/core/StarNetElementDynamicGroup.hpp
+++ b/source/core/StarNetElementDynamicGroup.hpp
@@ -91,7 +91,7 @@ auto NetElementDynamicGroup<Element>::addNetElement(ElementPtr element) -> Eleme
   readyElement(element);
   DataStreamBuffer storeBuffer;
   element->netStore(storeBuffer);
-  auto id = m_idMap.add(move(element));
+  auto id = m_idMap.add(std::move(element));
 
   addChangeData(ElementAddition(id, storeBuffer.takeData()));
 
@@ -192,7 +192,7 @@ void NetElementDynamicGroup<Element>::netLoad(DataStream& ds) {
     element->netLoad(storeBuffer);
     readyElement(element);
 
-    m_idMap.add(id, move(element));
+    m_idMap.add(id, std::move(element));
     addChangeData(ElementAddition(id, storeBuffer.takeData()));
   }
 }
@@ -256,10 +256,10 @@ void NetElementDynamicGroup<Element>::readNetDelta(DataStream& ds, float interpo
           m_idMap.clear();
         } else if (auto addition = changeUpdate.template ptr<ElementAddition>()) {
           ElementPtr element = make_shared<Element>();
-          DataStreamBuffer storeBuffer(move(get<1>(*addition)));
+          DataStreamBuffer storeBuffer(std::move(get<1>(*addition)));
           element->netLoad(storeBuffer);
           readyElement(element);
-          m_idMap.add(get<0>(*addition), move(element));
+          m_idMap.add(get<0>(*addition), std::move(element));
         } else if (auto removal = changeUpdate.template ptr<ElementRemoval>()) {
           m_idMap.remove(*removal);
         }
@@ -296,7 +296,7 @@ void NetElementDynamicGroup<Element>::addChangeData(ElementChange change) {
   uint64_t currentVersion = m_netVersion ? m_netVersion->current() : 0;
   starAssert(m_changeData.empty() || m_changeData.last().first <= currentVersion);
 
-  m_changeData.append({currentVersion, move(change)});
+  m_changeData.append({currentVersion, std::move(change)});
 
   m_changeDataLastVersion = max<int64_t>((int64_t)currentVersion - MaxChangeDataVersions, 0);
   while (!m_changeData.empty() && m_changeData.first().first < m_changeDataLastVersion)
diff --git a/source/core/StarNetElementFloatFields.hpp b/source/core/StarNetElementFloatFields.hpp
index 835b3ec..20895cd 100644
--- a/source/core/StarNetElementFloatFields.hpp
+++ b/source/core/StarNetElementFloatFields.hpp
@@ -92,7 +92,7 @@ void NetElementFloating<T>::setFixedPointBase(Maybe<T> fixedPointBase) {
 
 template <typename T>
 void NetElementFloating<T>::setInterpolator(function<T(T, T, T)> interpolator) {
-  m_interpolator = move(interpolator);
+  m_interpolator = std::move(interpolator);
 }
 
 template <typename T>
diff --git a/source/core/StarNetElementSignal.hpp b/source/core/StarNetElementSignal.hpp
index c1a89ac..03a2586 100644
--- a/source/core/StarNetElementSignal.hpp
+++ b/source/core/StarNetElementSignal.hpp
@@ -71,7 +71,7 @@ template <typename Signal>
 void NetElementSignal<Signal>::disableNetInterpolation() {
   m_netInterpolationEnabled = false;
   for (auto& p : take(m_pendingSignals))
-    send(move(p.second));
+    send(std::move(p.second));
 }
 
 template <typename Signal>
@@ -112,11 +112,11 @@ void NetElementSignal<Signal>::readNetDelta(DataStream& ds, float interpolationT
     if (m_netInterpolationEnabled && interpolationTime > 0.0f) {
       if (!m_pendingSignals.empty() && m_pendingSignals.last().first > interpolationTime) {
         for (auto& p : take(m_pendingSignals))
-          send(move(p.second));
+          send(std::move(p.second));
       }
-      m_pendingSignals.append({interpolationTime, move(s)});
+      m_pendingSignals.append({interpolationTime, std::move(s)});
     } else {
-      send(move(s));
+      send(std::move(s));
     }
   }
 }
diff --git a/source/core/StarNetElementSyncGroup.cpp b/source/core/StarNetElementSyncGroup.cpp
index 4ead00f..ac8da92 100644
--- a/source/core/StarNetElementSyncGroup.cpp
+++ b/source/core/StarNetElementSyncGroup.cpp
@@ -68,11 +68,11 @@ void NetElementSyncGroup::netElementsNeedLoad(bool) {}
 void NetElementSyncGroup::netElementsNeedStore() {}
 
 void NetElementCallbackGroup::setNeedsLoadCallback(function<void(bool)> needsLoadCallback) {
-  m_netElementsNeedLoad = move(needsLoadCallback);
+  m_netElementsNeedLoad = std::move(needsLoadCallback);
 }
 
 void NetElementCallbackGroup::setNeedsStoreCallback(function<void()> needsStoreCallback) {
-  m_netElementsNeedStore = move(needsStoreCallback);
+  m_netElementsNeedStore = std::move(needsStoreCallback);
 }
 
 void NetElementCallbackGroup::netElementsNeedLoad(bool load) {
diff --git a/source/core/StarNetElementTop.hpp b/source/core/StarNetElementTop.hpp
index fa85688..454b34f 100644
--- a/source/core/StarNetElementTop.hpp
+++ b/source/core/StarNetElementTop.hpp
@@ -68,7 +68,7 @@ void NetElementTop<BaseNetElement>::readNetState(ByteArray data, float interpola
     BaseNetElement::blankNetDelta(interpolationTime);
 
   } else {
-    DataStreamBuffer ds(move(data));
+    DataStreamBuffer ds(std::move(data));
 
     if (ds.read<bool>())
       BaseNetElement::netLoad(ds);
diff --git a/source/core/StarObserverStream.hpp b/source/core/StarObserverStream.hpp
index c97376c..61c4f91 100644
--- a/source/core/StarObserverStream.hpp
+++ b/source/core/StarObserverStream.hpp
@@ -61,7 +61,7 @@ void ObserverStream<T>::setHistoryLimit(uint64_t historyLimit) {
 
 template <typename T>
 void ObserverStream<T>::add(T value) {
-  m_values.append({m_nextStep, move(value)});
+  m_values.append({m_nextStep, std::move(value)});
   tick(1);
 }
 
diff --git a/source/core/StarOptionParser.cpp b/source/core/StarOptionParser.cpp
index f849f43..3cd32cc 100644
--- a/source/core/StarOptionParser.cpp
+++ b/source/core/StarOptionParser.cpp
@@ -4,29 +4,29 @@
 namespace Star {
 
 void OptionParser::setCommandName(String commandName) {
-  m_commandName = move(commandName);
+  m_commandName = std::move(commandName);
 }
 
 void OptionParser::setSummary(String summary) {
-  m_summary = move(summary);
+  m_summary = std::move(summary);
 }
 
 void OptionParser::setAdditionalHelp(String help) {
-  m_additionalHelp = move(help);
+  m_additionalHelp = std::move(help);
 }
 
 void OptionParser::addSwitch(String const& flag, String description) {
-  if (!m_options.insert(flag, Switch{flag, move(description)}).second)
+  if (!m_options.insert(flag, Switch{flag, std::move(description)}).second)
     throw OptionParserException::format("Duplicate switch '-{}' added", flag);
 }
 
 void OptionParser::addParameter(String const& flag, String argument, RequirementMode requirementMode, String description) {
-  if (!m_options.insert(flag, Parameter{flag, move(argument), requirementMode, move(description)}).second)
+  if (!m_options.insert(flag, Parameter{flag, std::move(argument), requirementMode, std::move(description)}).second)
     throw OptionParserException::format("Duplicate flag '-{}' added", flag);
 }
 
 void OptionParser::addArgument(String argument, RequirementMode requirementMode, String description) {
-  m_arguments.append(Argument{move(argument), requirementMode, move(description)});
+  m_arguments.append(Argument{std::move(argument), requirementMode, std::move(description)});
 }
 
 pair<OptionParser::Options, StringList> OptionParser::parseOptions(StringList const& arguments) const {
@@ -51,7 +51,7 @@ pair<OptionParser::Options, StringList> OptionParser::parseOptions(StringList co
       }
 
       if (option->is<Switch>()) {
-        result.switches.add(move(flag));
+        result.switches.add(std::move(flag));
       } else {
         auto const& parameter = option->get<Parameter>();
         if (!it.hasNext()) {
@@ -63,7 +63,7 @@ pair<OptionParser::Options, StringList> OptionParser::parseOptions(StringList co
           errors.append(strf("Option with argument '-{}' specified multiple times", flag));
           continue;
         }
-        result.parameters[move(flag)].append(move(val));
+        result.parameters[std::move(flag)].append(std::move(val));
       }
 
     } else {
@@ -96,7 +96,7 @@ pair<OptionParser::Options, StringList> OptionParser::parseOptions(StringList co
     errors.append(strf(
         "Too many positional arguments given, expected at most {} got {}", maximumArguments, result.arguments.size()));
 
-  return {move(result), move(errors)};
+  return {std::move(result), std::move(errors)};
 }
 
 void OptionParser::printHelp(std::ostream& os) const {
diff --git a/source/core/StarOrderedMap.hpp b/source/core/StarOrderedMap.hpp
index 4f2dc22..be99769 100644
--- a/source/core/StarOrderedMap.hpp
+++ b/source/core/StarOrderedMap.hpp
@@ -192,7 +192,7 @@ OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::OrderedMapWrapper(Inp
 template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
 OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::OrderedMapWrapper(initializer_list<value_type> list) {
   for (value_type v : list)
-    insert(move(v));
+    insert(std::move(v));
 }
 
 template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
@@ -242,7 +242,7 @@ template <template <typename...> class Map, typename Key, typename Value, typena
 auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::value(key_type const& k, mapped_type d) const -> mapped_type {
   auto i = m_map.find(k);
   if (i == m_map.end())
-    return move(d);
+    return d;
   else
     return i->second->second;
 }
@@ -335,7 +335,7 @@ auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insert(value_typ
 
 template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
 auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insert(key_type k, mapped_type v) -> pair<iterator, bool> {
-  return insert(value_type(move(k), move(v)));
+  return insert(value_type(std::move(k), std::move(v)));
 }
 
 template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
@@ -352,12 +352,12 @@ auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insertFront(valu
 
 template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
 auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insertFront(key_type k, mapped_type v) -> pair<iterator, bool> {
-  return insertFront(value_type(move(k), move(v)));
+  return insertFront(value_type(std::move(k), std::move(v)));
 }
 
 template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
 auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::add(key_type k, mapped_type v) -> mapped_type& {
-  auto pair = insert(value_type(move(k), move(v)));
+  auto pair = insert(value_type(std::move(k), std::move(v)));
   if (!pair.second)
     throw MapException(strf("Entry with key '{}' already present.", outputAny(k)));
   else
@@ -368,10 +368,10 @@ template <template <typename...> class Map, typename Key, typename Value, typena
 auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::set(key_type k, mapped_type v) -> mapped_type& {
   auto i = find(k);
   if (i != end()) {
-    i->second = move(v);
+    i->second = std::move(v);
     return i->second;
   } else {
-    return insert(value_type(move(k), move(v))).first->second;
+    return insert(value_type(std::move(k), std::move(v))).first->second;
   }
 }
 
@@ -575,11 +575,11 @@ template <template <typename...> class Map, typename Key, typename Value, typena
 auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insert(iterator pos, value_type v) -> iterator {
   auto i = m_map.find(v.first);
   if (i == m_map.end()) {
-    iterator orderIt = m_order.insert(pos, move(v));
+    iterator orderIt = m_order.insert(pos, std::move(v));
     m_map.insert(typename MapType::value_type(std::cref(orderIt->first), orderIt));
     return orderIt;
   } else {
-    i->second->second = move(v.second);
+    i->second->second = std::move(v.second);
     m_order.splice(pos, m_order, i->second);
     return i->second;
   }
diff --git a/source/core/StarOrderedSet.hpp b/source/core/StarOrderedSet.hpp
index 1f42132..abfb19b 100644
--- a/source/core/StarOrderedSet.hpp
+++ b/source/core/StarOrderedSet.hpp
@@ -167,7 +167,7 @@ template <template <typename...> class Map, typename Value, typename Allocator,
 auto OrderedSetWrapper<Map, Value, Allocator, Args...>::values() const -> List<value_type> {
   List<value_type> values;
   for (auto p : *this)
-    values.append(move(p));
+    values.append(std::move(p));
   return values;
 }
 
diff --git a/source/core/StarOutputProxy.hpp b/source/core/StarOutputProxy.hpp
index 6449d94..d8761fa 100644
--- a/source/core/StarOutputProxy.hpp
+++ b/source/core/StarOutputProxy.hpp
@@ -49,7 +49,7 @@ struct OutputProxy {
   typedef function<void(std::ostream&)> PrintFunction;
 
   OutputProxy(PrintFunction p)
-    : print(move(p)) {}
+    : print(std::move(p)) {}
 
   PrintFunction print;
 };
diff --git a/source/core/StarParametricFunction.hpp b/source/core/StarParametricFunction.hpp
index 8221c05..64bede2 100644
--- a/source/core/StarParametricFunction.hpp
+++ b/source/core/StarParametricFunction.hpp
@@ -125,8 +125,8 @@ ParametricTable<IndexType, ValueType>::ParametricTable(PairContainer indexValueP
       });
 
   for (auto const& pair : indexValuePairs) {
-    m_indexes.push_back(move(std::get<0>(pair)));
-    m_values.push_back(move(std::get<1>(pair)));
+    m_indexes.push_back(std::move(std::get<0>(pair)));
+    m_values.push_back(std::move(std::get<1>(pair)));
   }
 
   for (size_t i = 0; i < size() - 1; ++i) {
@@ -138,8 +138,8 @@ ParametricTable<IndexType, ValueType>::ParametricTable(PairContainer indexValueP
 template <typename IndexType, typename ValueType>
 size_t ParametricTable<IndexType, ValueType>::addPoint(IndexType index, ValueType value) {
   size_t insertLocation = std::distance(m_indexes.begin(), std::upper_bound(m_indexes.begin(), m_indexes.end(), index));
-  m_indexes.insert(m_indexes.begin() + insertLocation, move(index));
-  m_values.insert(m_values.begin() + insertLocation, move(value));
+  m_indexes.insert(m_indexes.begin() + insertLocation, std::move(index));
+  m_values.insert(m_values.begin() + insertLocation, std::move(value));
   return insertLocation;
 }
 
diff --git a/source/core/StarPerlin.hpp b/source/core/StarPerlin.hpp
index b042e47..294f80f 100644
--- a/source/core/StarPerlin.hpp
+++ b/source/core/StarPerlin.hpp
@@ -210,7 +210,7 @@ Perlin<Float>::Perlin(Perlin const& perlin) {
 
 template <typename Float>
 Perlin<Float>::Perlin(Perlin&& perlin) {
-  *this = move(perlin);
+  *this = std::move(perlin);
 }
 
 template <typename Float>
@@ -261,10 +261,10 @@ Perlin<Float>& Perlin<Float>::operator=(Perlin&& perlin) {
   m_offset = perlin.m_offset;
   m_gain = perlin.m_gain;
 
-  p = move(perlin.p);
-  g3 = move(perlin.g3);
-  g2 = move(perlin.g2);
-  g1 = move(perlin.g1);
+  p = std::move(perlin.p);
+  g3 = std::move(perlin.g3);
+  g2 = std::move(perlin.g2);
+  g1 = std::move(perlin.g1);
 
   return *this;
 }
diff --git a/source/core/StarPoly.hpp b/source/core/StarPoly.hpp
index 58cfca8..806b495 100644
--- a/source/core/StarPoly.hpp
+++ b/source/core/StarPoly.hpp
@@ -186,7 +186,7 @@ Polygon<DataType> Polygon<DataType>::convexHull(VertexList points) {
   upper.removeLast();
   lower.removeLast();
   lower.appendAll(take(upper));
-  return Polygon<DataType>(move(lower));
+  return Polygon<DataType>(std::move(lower));
 }
 
 template <typename DataType>
@@ -218,7 +218,7 @@ Polygon<DataType> Polygon<DataType>::clip(Polygon inputPoly, Polygon convexClipP
     }
   }
 
-  return Polygon(move(outputVertexes));
+  return Polygon(std::move(outputVertexes));
 }
 
 template <typename DataType>
@@ -230,7 +230,7 @@ Polygon<DataType>::Polygon(Polygon const& rhs)
 
 template <typename DataType>
 Polygon<DataType>::Polygon(Polygon&& rhs)
-  : m_vertexes(move(rhs.m_vertexes)) {}
+  : m_vertexes(std::move(rhs.m_vertexes)) {}
 
 template <typename DataType>
 template <typename DataType2>
@@ -303,7 +303,7 @@ void Polygon<DataType>::deduplicateVertexes(float maxDistance) {
   if (vmagSquared(newVertexes.first() - newVertexes.last()) <= distSquared)
     newVertexes.removeLast();
 
-  m_vertexes = move(newVertexes);
+  m_vertexes = std::move(newVertexes);
 }
 
 template <typename DataType>
@@ -426,7 +426,7 @@ Polygon<DataType>& Polygon<DataType>::operator=(Polygon const& rhs) {
 
 template <typename DataType>
 Polygon<DataType>& Polygon<DataType>::operator=(Polygon&& rhs) {
-  m_vertexes = move(rhs.m_vertexes);
+  m_vertexes = std::move(rhs.m_vertexes);
   return *this;
 }
 
diff --git a/source/core/StarPythonic.hpp b/source/core/StarPythonic.hpp
index 0bfdc50..0131130 100644
--- a/source/core/StarPythonic.hpp
+++ b/source/core/StarPythonic.hpp
@@ -599,7 +599,7 @@ template <typename ResultContainer, typename Iterable>
 ResultContainer enumerateConstruct(Iterable&& list) {
   ResultContainer res;
   for (auto el : enumerateIterator(list))
-    res.push_back(move(el));
+    res.push_back(std::move(el));
 
   return res;
 }
diff --git a/source/core/StarRefPtr.hpp b/source/core/StarRefPtr.hpp
index 906d4ff..8fabcdb 100644
--- a/source/core/StarRefPtr.hpp
+++ b/source/core/StarRefPtr.hpp
@@ -278,7 +278,7 @@ RefPtr<Type1 const> as(RefPtr<Type2 const> const& p) {
 
 template <typename T, typename... Args>
 RefPtr<T> make_ref(Args&&... args) {
-  return RefPtr<T>(new T(forward<Args>(args)...));
+  return RefPtr<T>(new T(std::forward<Args>(args)...));
 }
 
 template <typename T>
diff --git a/source/core/StarRpcPromise.hpp b/source/core/StarRpcPromise.hpp
index dcfd242..7a08750 100644
--- a/source/core/StarRpcPromise.hpp
+++ b/source/core/StarRpcPromise.hpp
@@ -70,17 +70,17 @@ private:
 
 template <typename Result, typename Error>
 void RpcPromiseKeeper<Result, Error>::fulfill(Result result) {
-  m_fulfill(move(result));
+  m_fulfill(std::move(result));
 }
 
 template <typename Result, typename Error>
 void RpcPromiseKeeper<Result, Error>::fail(Error error) {
-  m_fail(move(error));
+  m_fail(std::move(error));
 }
 
 template <typename Result, typename Error>
 pair<RpcPromise<Result, Error>, RpcPromiseKeeper<Result, Error>> RpcPromise<Result, Error>::createPair() {
-  auto valuePtr = make_shared<Value>();
+  auto valuePtr = std::make_shared<Value>();
 
   RpcPromise promise;
   promise.m_getValue = [valuePtr]() {
@@ -91,21 +91,21 @@ pair<RpcPromise<Result, Error>, RpcPromiseKeeper<Result, Error>> RpcPromise<Resu
   keeper.m_fulfill = [valuePtr](Result result) {
     if (valuePtr->result || valuePtr->error)
       throw RpcPromiseException("fulfill called on already finished RpcPromise");
-    valuePtr->result = move(result);
+    valuePtr->result = std::move(result);
   };
   keeper.m_fail = [valuePtr](Error error) {
     if (valuePtr->result || valuePtr->error)
       throw RpcPromiseException("fail called on already finished RpcPromise");
-    valuePtr->error = move(error);
+    valuePtr->error = std::move(error);
   };
 
-  return {move(promise), move(keeper)};
+  return {std::move(promise), std::move(keeper)};
 }
 
 template <typename Result, typename Error>
 RpcPromise<Result, Error> RpcPromise<Result, Error>::createFulfilled(Result result) {
-  auto valuePtr = make_shared<Value>();
-  valuePtr->result = move(result);
+  auto valuePtr = std::make_shared<Value>();
+  valuePtr->result = std::move(result);
 
   RpcPromise<Result, Error> promise;
   promise.m_getValue = [valuePtr]() {
@@ -116,8 +116,8 @@ RpcPromise<Result, Error> RpcPromise<Result, Error>::createFulfilled(Result resu
 
 template <typename Result, typename Error>
 RpcPromise<Result, Error> RpcPromise<Result, Error>::createFailed(Error error) {
-  auto valuePtr = make_shared<Value>();
-  valuePtr->error = move(error);
+  auto valuePtr = std::make_shared<Value>();
+  valuePtr->error = std::move(error);
 
   RpcPromise<Result, Error> promise;
   promise.m_getValue = [valuePtr]() {
@@ -157,7 +157,7 @@ template <typename Function>
 decltype(auto) RpcPromise<Result, Error>::wrap(Function function) {
   typedef RpcPromise<typename std::decay<decltype(function(std::declval<Result>()))>::type, Error> WrappedPromise;
   WrappedPromise wrappedPromise;
-  wrappedPromise.m_getValue = [wrapper = move(function), valuePtr = make_shared<typename WrappedPromise::Value>(), otherGetValue = m_getValue]() {
+  wrappedPromise.m_getValue = [wrapper = std::move(function), valuePtr = std::make_shared<typename WrappedPromise::Value>(), otherGetValue = m_getValue]() {
     if (!valuePtr->result && !valuePtr->error) {
       auto otherValue = otherGetValue();
       if (otherValue->result)
diff --git a/source/core/StarRpcThreadPromise.hpp b/source/core/StarRpcThreadPromise.hpp
index bae509c..043d0e7 100644
--- a/source/core/StarRpcThreadPromise.hpp
+++ b/source/core/StarRpcThreadPromise.hpp
@@ -66,12 +66,12 @@ private:
 
 template <typename Result, typename Error>
 void RpcThreadPromiseKeeper<Result, Error>::fulfill(Result result) {
-  m_fulfill(move(result));
+  m_fulfill(std::move(result));
 }
 
 template <typename Result, typename Error>
 void RpcThreadPromiseKeeper<Result, Error>::fail(Error error) {
-  m_fail(move(error));
+  m_fail(std::move(error));
 }
 
 template <typename Result, typename Error>
@@ -88,22 +88,22 @@ pair<RpcThreadPromise<Result, Error>, RpcThreadPromiseKeeper<Result, Error>> Rpc
     MutexLocker lock(valuePtr->mutex);
     if (valuePtr->result || valuePtr->error)
       throw RpcThreadPromiseException("fulfill called on already finished RpcThreadPromise");
-    valuePtr->result = move(result);
+    valuePtr->result = std::move(result);
   };
   keeper.m_fail = [valuePtr](Error error) {
     MutexLocker lock(valuePtr->mutex);
     if (valuePtr->result || valuePtr->error)
       throw RpcThreadPromiseException("fail called on already finished RpcThreadPromise");
-    valuePtr->error = move(error);
+    valuePtr->error = std::move(error);
   };
 
-  return {move(promise), move(keeper)};
+  return {std::move(promise), std::move(keeper)};
 }
 
 template <typename Result, typename Error>
 RpcThreadPromise<Result, Error> RpcThreadPromise<Result, Error>::createFulfilled(Result result) {
   auto valuePtr = make_shared<Value>();
-  valuePtr->result = move(result);
+  valuePtr->result = std::move(result);
 
   RpcThreadPromise<Result, Error> promise;
   promise.m_getValue = [valuePtr]() {
@@ -115,7 +115,7 @@ RpcThreadPromise<Result, Error> RpcThreadPromise<Result, Error>::createFulfilled
 template <typename Result, typename Error>
 RpcThreadPromise<Result, Error> RpcThreadPromise<Result, Error>::createFailed(Error error) {
   auto valuePtr = make_shared<Value>();
-  valuePtr->error = move(error);
+  valuePtr->error = std::move(error);
 
   RpcThreadPromise<Result, Error> promise;
   promise.m_getValue = [valuePtr]() {
diff --git a/source/core/StarSectorArray2D.hpp b/source/core/StarSectorArray2D.hpp
index 4645804..1dd88a1 100644
--- a/source/core/StarSectorArray2D.hpp
+++ b/source/core/StarSectorArray2D.hpp
@@ -213,7 +213,7 @@ auto SectorArray2D<ElementT, SectorSize>::sector(Sector const& id) const -> Arra
 template <typename ElementT, size_t SectorSize>
 void SectorArray2D<ElementT, SectorSize>::loadSector(Sector const& id, ArrayPtr array) {
   auto& data = m_sectors(id[0], id[1]);
-  data = move(array);
+  data = std::move(array);
   if (data)
     m_loadedSectors.add(id);
   else
@@ -224,7 +224,7 @@ template <typename ElementT, size_t SectorSize>
 typename SectorArray2D<ElementT, SectorSize>::ArrayPtr SectorArray2D<ElementT, SectorSize>::copySector(
     Sector const& id) {
   if (auto const& array = m_sectors(id))
-    return make_unique<Array>(*array);
+    return std::make_unique<Array>(*array);
   else
     return {};
 }
@@ -235,7 +235,7 @@ typename SectorArray2D<ElementT, SectorSize>::ArrayPtr SectorArray2D<ElementT, S
   ArrayPtr ret;
   m_loadedSectors.remove(id);
   std::swap(m_sectors(id[0], id[1]), ret);
-  return move(ret);
+  return ret;
 }
 
 template <typename ElementT, size_t SectorSize>
@@ -268,14 +268,14 @@ template <typename ElementT, size_t SectorSize>
 template <typename Function>
 bool SectorArray2D<ElementT, SectorSize>::eval(
     size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) const {
-  return const_cast<SectorArray2D*>(this)->evalPriv(minX, minY, width, height, forward<Function>(function), evalEmpty);
+  return const_cast<SectorArray2D*>(this)->evalPriv(minX, minY, width, height, std::forward<Function>(function), evalEmpty);
 }
 
 template <typename ElementT, size_t SectorSize>
 template <typename Function>
 bool SectorArray2D<ElementT, SectorSize>::eval(
     size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) {
-  return evalPriv(minX, minY, width, height, forward<Function>(function), evalEmpty);
+  return evalPriv(minX, minY, width, height, std::forward<Function>(function), evalEmpty);
 }
 
 template <typename ElementT, size_t SectorSize>
@@ -283,14 +283,14 @@ template <typename Function>
 bool SectorArray2D<ElementT, SectorSize>::evalColumns(
     size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) const {
   return const_cast<SectorArray2D*>(this)->evalColumnsPriv(
-      minX, minY, width, height, forward<Function>(function), evalEmpty);
+      minX, minY, width, height, std::forward<Function>(function), evalEmpty);
 }
 
 template <typename ElementT, size_t SectorSize>
 template <typename Function>
 bool SectorArray2D<ElementT, SectorSize>::evalColumns(
     size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) {
-  return evalColumnsPriv(minX, minY, width, height, forward<Function>(function), evalEmpty);
+  return evalColumnsPriv(minX, minY, width, height, std::forward<Function>(function), evalEmpty);
 }
 
 template <typename ElementT, size_t SectorSize>
diff --git a/source/core/StarSet.hpp b/source/core/StarSet.hpp
index 8950e9c..f32a46c 100644
--- a/source/core/StarSet.hpp
+++ b/source/core/StarSet.hpp
@@ -129,7 +129,7 @@ bool SetMixin<BaseSet>::add(value_type const& v) {
 template <typename BaseSet>
 bool SetMixin<BaseSet>::replace(value_type v) {
   bool replaced = remove(v);
-  Base::insert(move(v));
+  Base::insert(std::move(v));
   return replaced;
 }
 
@@ -170,7 +170,7 @@ auto SetMixin<BaseSet>::takeFirst() -> value_type {
   if (Base::empty())
     throw SetException("takeFirst called on empty set");
   auto i = Base::begin();
-  value_type v = move(*i);
+  value_type v = std::move(*i);
   Base::erase(i);
   return v;
 }
@@ -180,9 +180,9 @@ auto SetMixin<BaseSet>::maybeTakeFirst() -> Maybe<value_type> {
   if (Base::empty())
     return {};
   auto i = Base::begin();
-  value_type v = move(*i);
+  value_type v = std::move(*i);
   Base::erase(i);
-  return move(v);
+  return std::move(v);
 }
 
 template <typename BaseSet>
@@ -204,7 +204,7 @@ auto SetMixin<BaseSet>::takeLast() -> value_type {
   if (Base::empty())
     throw SetException("takeLast called on empty set");
   auto i = prev(Base::end());
-  value_type v = move(*i);
+  value_type v = std::move(*i);
   Base::erase(i);
   return v;
 }
@@ -214,9 +214,9 @@ auto SetMixin<BaseSet>::maybeTakeLast() -> Maybe<value_type> {
   if (Base::empty())
     return {};
   auto i = prev(Base::end());
-  value_type v = move(*i);
+  value_type v = std::move(*i);
   Base::erase(i);
-  return move(v);
+  return std::move(v);
 }
 
 template <typename BaseSet>
diff --git a/source/core/StarShellParser.cpp b/source/core/StarShellParser.cpp
index 31a927e..0551281 100644
--- a/source/core/StarShellParser.cpp
+++ b/source/core/StarShellParser.cpp
@@ -21,7 +21,7 @@ StringList ShellParser::tokenizeToStringList(String const& command) {
   StringList res;
   for (auto token : tokenize(command)) {
     if (token.type == TokenType::Word) {
-      res.append(move(token.token));
+      res.append(std::move(token.token));
     }
   }
 
diff --git a/source/core/StarSmallVector.hpp b/source/core/StarSmallVector.hpp
index 2a77a3d..77dc7a5 100644
--- a/source/core/StarSmallVector.hpp
+++ b/source/core/StarSmallVector.hpp
@@ -122,7 +122,7 @@ template <typename Element, size_t MaxStackSize>
 SmallVector<Element, MaxStackSize>::SmallVector(SmallVector&& other)
   : SmallVector() {
     for (auto& e : other)
-      emplace_back(move(e));
+      emplace_back(std::move(e));
 }
 
 template <typename Element, size_t MaxStackSize>
@@ -169,7 +169,7 @@ template <typename Element, size_t MaxStackSize>
 auto SmallVector<Element, MaxStackSize>::operator=(SmallVector&& other) -> SmallVector& {
   resize(other.size());
   for (size_t i = 0; i < size(); ++i)
-    operator[](i) = move(other[i]);
+    operator[](i) = std::move(other[i]);
 
   return *this;
 }
@@ -178,7 +178,7 @@ template <typename Element, size_t MaxStackSize>
 auto SmallVector<Element, MaxStackSize>::operator=(std::initializer_list<Element> list) -> SmallVector& {
   resize(list.size());
   for (size_t i = 0; i < size(); ++i)
-    operator[](i) = move(list[i]);
+    operator[](i) = std::move(list[i]);
   return *this;
 }
 
@@ -217,7 +217,7 @@ void SmallVector<Element, MaxStackSize>::reserve(size_t newCapacity) {
 
     // We assume that move constructors can never throw.
     for (size_t i = 0; i < size; ++i) {
-      new (&newMem[i]) Element(move(oldMem[i]));
+      new (&newMem[i]) Element(std::move(oldMem[i]));
     }
 
     m_begin = newMem;
@@ -313,7 +313,7 @@ Element* SmallVector<Element, MaxStackSize>::ptr() {
 
 template <typename Element, size_t MaxStackSize>
 void SmallVector<Element, MaxStackSize>::push_back(Element e) {
-  emplace_back(move(e));
+  emplace_back(std::move(e));
 }
 
 template <typename Element, size_t MaxStackSize>
@@ -326,7 +326,7 @@ void SmallVector<Element, MaxStackSize>::pop_back() {
 
 template <typename Element, size_t MaxStackSize>
 auto SmallVector<Element, MaxStackSize>::insert(iterator pos, Element e) -> iterator {
-  emplace(pos, move(e));
+  emplace(pos, std::move(e));
   return pos;
 }
 
@@ -341,7 +341,7 @@ auto SmallVector<Element, MaxStackSize>::insert(iterator pos, Iterator begin, It
   resize(size() + toAdd);
 
   for (size_t i = toShift; i != 0; --i)
-    operator[](endIndex + i - 1) = move(operator[](startIndex + i - 1));
+    operator[](endIndex + i - 1) = std::move(operator[](startIndex + i - 1));
 
   for (size_t i = 0; i != toAdd; ++i)
     operator[](startIndex + i) = *begin++;
@@ -360,8 +360,8 @@ void SmallVector<Element, MaxStackSize>::emplace(iterator pos, Args&&... args) {
   size_t index = pos - m_begin;
   emplace_back(Element());
   for (size_t i = size() - 1; i != index; --i)
-    operator[](i) = move(operator[](i - 1));
-  operator[](index) = Element(forward<Args>(args)...);
+    operator[](i) = std::move(operator[](i - 1));
+  operator[](index) = Element(std::forward<Args>(args)...);
 }
 
 template <typename Element, size_t MaxStackSize>
@@ -369,7 +369,7 @@ template <typename... Args>
 void SmallVector<Element, MaxStackSize>::emplace_back(Args&&... args) {
   if (m_end == m_capacity)
     reserve(size() + 1);
-  new (m_end) Element(forward<Args>(args)...);
+  new (m_end) Element(std::forward<Args>(args)...);
   ++m_end;
 }
 
@@ -383,7 +383,7 @@ template <typename Element, size_t MaxStackSize>
 auto SmallVector<Element, MaxStackSize>::erase(iterator pos) -> iterator {
   size_t index = pos - ptr();
   for (size_t i = index; i < size() - 1; ++i)
-    operator[](i) = move(operator[](i + 1));
+    operator[](i) = std::move(operator[](i + 1));
   pop_back();
   return pos;
 }
@@ -394,7 +394,7 @@ auto SmallVector<Element, MaxStackSize>::erase(iterator begin, iterator end) ->
   size_t endIndex = end - ptr();
   size_t toRemove = endIndex - startIndex;
   for (size_t i = endIndex; i < size(); ++i)
-    operator[](startIndex + (i - endIndex)) = move(operator[](i));
+    operator[](startIndex + (i - endIndex)) = std::move(operator[](i));
   resize(size() - toRemove);
   return begin;
 }
diff --git a/source/core/StarSocket.cpp b/source/core/StarSocket.cpp
index 9b866b8..dbe1439 100644
--- a/source/core/StarSocket.cpp
+++ b/source/core/StarSocket.cpp
@@ -96,7 +96,7 @@ Maybe<SocketPollResult> Socket::poll(SocketPollQuery const& query, unsigned time
       pr.exception = pfd.revents & POLLHUP || pfd.revents & POLLNVAL || pfd.revents & POLLERR;
       if (pfd.revents & POLLHUP)
         p.first.first->doShutdown();
-      result.add(p.first.first, move(pr));
+      result.add(p.first.first, std::move(pr));
     }
   }
 #endif
diff --git a/source/core/StarSpatialHash2D.hpp b/source/core/StarSpatialHash2D.hpp
index 2241dfd..87f70e3 100644
--- a/source/core/StarSpatialHash2D.hpp
+++ b/source/core/StarSpatialHash2D.hpp
@@ -239,19 +239,19 @@ void SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::set(Key con
 
 template <typename KeyT, typename ScalarT, typename ValueT, typename IntT, size_t AllocatorBlockSize>
 void SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::set(Key const& key, Coord const& pos, Value value) {
-  set(key, {Rect(pos, pos)}, move(value));
+  set(key, {Rect(pos, pos)}, std::move(value));
 }
 
 template <typename KeyT, typename ScalarT, typename ValueT, typename IntT, size_t AllocatorBlockSize>
 void SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::set(Key const& key, Rect const& rect, Value value) {
-  set(key, {rect}, move(value));
+  set(key, {rect}, std::move(value));
 }
 
 template <typename KeyT, typename ScalarT, typename ValueT, typename IntT, size_t AllocatorBlockSize>
 template <typename RectCollection>
 void SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::set(Key const& key, RectCollection const& rects, Value value) {
   Entry& entry = m_entryMap[key];
-  entry.value = move(value);
+  entry.value = std::move(value);
   updateSpatial(&entry, rects);
 }
 
@@ -262,7 +262,7 @@ auto SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::remove(Key
     return {};
 
   removeSpatial(&iter->second);
-  Maybe<Value> val = move(iter->second.value);
+  Maybe<Value> val = std::move(iter->second.value);
   m_entryMap.erase(iter);
   return val;
 }
diff --git a/source/core/StarStaticVector.hpp b/source/core/StarStaticVector.hpp
index 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);