diff --git a/atdna/main.cpp b/atdna/main.cpp
index 3f3ad92..c079700 100644
--- a/atdna/main.cpp
+++ b/atdna/main.cpp
@@ -91,9 +91,9 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
             bool hasWrite = false;
             for (const clang::CXXMethodDecl* method : rDecl->methods()) {
               std::string compName = method->getDeclName().getAsString();
-              if (!compName.compare("read"))
+              if (compName == "read")
                 hasRead = true;
-              else if (!compName.compare("write"))
+              else if (compName == "write")
                 hasWrite = true;
             }
             if (hasRead && hasWrite) {
@@ -130,7 +130,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
     } else if (theType->isRecordType()) {
       const clang::CXXRecordDecl* rDecl = theType->getAsCXXRecordDecl();
       for (const clang::FieldDecl* field : rDecl->fields()) {
-        if (!field->getName().compare("clangVec")) {
+        if (field->getName() == "clangVec") {
           const auto* vType = static_cast<const clang::VectorType*>(field->getType().getTypePtr());
           if (vType->isVectorType()) {
             const auto* eType = static_cast<const clang::BuiltinType*>(vType->getElementType().getTypePtr());
@@ -164,7 +164,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
 
   static std::string GetPropIdExpr(const clang::FieldDecl* field, const std::string& fieldName) {
     std::string fieldStr = GetFieldString(fieldName);
-    std::string propIdExpr = "\"" + fieldStr + "\"";
+    std::string propIdExpr = "\"" + fieldStr + "\"sv";
     for (clang::Attr* attr : field->attrs()) {
       if (clang::AnnotateAttr* annot = clang::dyn_cast_or_null<clang::AnnotateAttr>(attr)) {
         llvm::StringRef textRef = annot->getAnnotation();
@@ -172,7 +172,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
           unsigned long num = strtoul(textRef.data() + 7, nullptr, 16);
           std::string tmpS;
           llvm::raw_string_ostream s(tmpS);
-          s << llvm::format("\"%s\", 0x%08X", fieldStr.c_str(), num);
+          s << llvm::format("\"%s\"sv, 0x%08X", fieldStr.c_str(), num);
           propIdExpr = s.str();
           break;
         }
@@ -366,7 +366,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
         const clang::TemplateDecl* tsDecl = tsType->getTemplateName().getAsTemplateDecl();
         const clang::TemplateParameterList* classParms = tsDecl->getTemplateParameters();
 
-        if (!tsDecl->getName().compare("Value")) {
+        if (tsDecl->getName() == "Value") {
           llvm::APSInt endian(64, -1);
           std::string endianExprStr;
           bool defaultEndian = true;
@@ -407,7 +407,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
           }
 
           outputNodes.emplace_back(NodeType::Do, fieldName, ioOp, false);
-        } else if (!tsDecl->getName().compare("Vector")) {
+        } else if (tsDecl->getName() == "Vector") {
           llvm::APSInt endian(64, -1);
           std::string endianExprStr;
           bool defaultEndian = true;
@@ -483,7 +483,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
           }
 
           outputNodes.emplace_back(NodeType::Do, fieldName, ioOp, false);
-        } else if (!tsDecl->getName().compare("Buffer")) {
+        } else if (tsDecl->getName() == "Buffer") {
           const clang::Expr* sizeExpr = nullptr;
           std::string sizeExprStr;
           for (const clang::TemplateArgument& arg : *tsType) {
@@ -516,7 +516,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
           std::string ioOp = GetVectorOpString(fieldName, propIdExpr, sizeExprStr);
 
           outputNodes.emplace_back(NodeType::Do, fieldName, ioOp, false);
-        } else if (!tsDecl->getName().compare("String")) {
+        } else if (tsDecl->getName() == "String") {
           std::string sizeExprStr;
           for (const clang::TemplateArgument& arg : *tsType) {
             if (arg.getKind() == clang::TemplateArgument::Expression) {
@@ -543,7 +543,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
             ioOp = GetOpString(fieldName, propIdExpr);
 
           outputNodes.emplace_back(NodeType::Do, fieldName, ioOp, false);
-        } else if (!tsDecl->getName().compare("WString")) {
+        } else if (tsDecl->getName() == "WString") {
           llvm::APSInt endian(64, -1);
           std::string endianExprStr;
           bool defaultEndian = true;
@@ -597,7 +597,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
           }
 
           outputNodes.emplace_back(NodeType::Do, fieldName, ioOp, false);
-        } else if (!tsDecl->getName().compare("Seek")) {
+        } else if (tsDecl->getName() == "Seek") {
           size_t idx = 0;
           std::string offsetExprStr;
           llvm::APSInt direction(64, 0);
@@ -659,7 +659,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
           else if (directionVal == 2)
             outputNodes.emplace_back(NodeType::DoSeek, fieldName, "<Op>("s + offsetExprStr + ", athena::End, s)",
                                      false);
-        } else if (!tsDecl->getName().compare("Align")) {
+        } else if (tsDecl->getName() == "Align") {
           llvm::APSInt align(64, 0);
           bool bad = false;
           for (const clang::TemplateArgument& arg : *tsType) {
@@ -758,7 +758,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
         const clang::TemplateDecl* tsDecl = tsType->getTemplateName().getAsTemplateDecl();
         const clang::TemplateParameterList* classParms = tsDecl->getTemplateParameters();
 
-        if (!tsDecl->getName().compare("Value")) {
+        if (tsDecl->getName() == "Value") {
           llvm::APSInt endian(64, -1);
           std::string endianExprStr;
           bool defaultEndian = true;
@@ -802,7 +802,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
                   << "    Do" << ioOp << ";\n"
                   << "    return true;\n";
 
-        } else if (!tsDecl->getName().compare("Vector")) {
+        } else if (tsDecl->getName() == "Vector") {
           llvm::APSInt endian(64, -1);
           std::string endianExprStr;
           bool defaultEndian = true;
@@ -869,7 +869,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
           fileOut << "  AT_PROP_CASE(" << propIdExpr << "):\n"
                   << "    Do" << ioOp << ";\n"
                   << "    return true;\n";
-        } else if (!tsDecl->getName().compare("Buffer")) {
+        } else if (tsDecl->getName() == "Buffer") {
           const clang::Expr* sizeExpr = nullptr;
           std::string sizeExprStr;
           for (const clang::TemplateArgument& arg : *tsType) {
@@ -904,7 +904,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
           fileOut << "  AT_PROP_CASE(" << propIdExpr << "):\n"
                   << "    Do" << ioOp << ";\n"
                   << "    return true;\n";
-        } else if (!tsDecl->getName().compare("String")) {
+        } else if (tsDecl->getName() == "String") {
           std::string sizeExprStr;
           for (const clang::TemplateArgument& arg : *tsType) {
             if (arg.getKind() == clang::TemplateArgument::Expression) {
@@ -933,7 +933,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor> {
           fileOut << "  AT_PROP_CASE(" << propIdExpr << "):\n"
                   << "    Do" << ioOp << ";\n"
                   << "    return true;\n";
-        } else if (!tsDecl->getName().compare("WString")) {
+        } else if (tsDecl->getName() == "WString") {
           llvm::APSInt endian(64, -1);
           std::string endianExprStr;
           bool defaultEndian = true;
@@ -1038,8 +1038,7 @@ public:
     bool isYamlDNA = false;
     for (const clang::CXXMethodDecl* method : decl->methods())
       if (method->getDeclName().isIdentifier() &&
-          (!method->getName().compare(llvm::StringLiteral("read")) ||
-           !method->getName().compare(llvm::StringLiteral("write"))) &&
+          (method->getName() == "read" || method->getName() == "write") &&
           method->getNumParams() == 1 &&
           method->getParamDecl(0)->getType().getAsString() == "athena::io::YAMLDocReader &") {
         isYamlDNA = true;
@@ -1050,7 +1049,7 @@ public:
     bool isPropDNA = false;
     for (const clang::Decl* d : decl->decls())
       if (const clang::FunctionTemplateDecl* m = clang::dyn_cast_or_null<clang::FunctionTemplateDecl>(d))
-        if (m->getDeclName().isIdentifier() && !m->getName().compare(llvm::StringLiteral("Lookup"))) {
+        if (m->getDeclName().isIdentifier() && m->getName() == "Lookup") {
           isPropDNA = true;
           break;
         }
@@ -1062,7 +1061,7 @@ public:
       if (regType) {
         const clang::CXXRecordDecl* rDecl = regType->getAsCXXRecordDecl();
         if (rDecl) {
-          if (!rDecl->getName().compare("Delete")) {
+          if (rDecl->getName() == "Delete") {
             const clang::CXXRecordDecl* rParentDecl = llvm::dyn_cast_or_null<clang::CXXRecordDecl>(rDecl->getParent());
             if (rParentDecl) {
               std::string parentCheck = rParentDecl->getTypeForDecl()->getCanonicalTypeInternal().getAsString();
@@ -1093,8 +1092,8 @@ public:
     for (const auto& specialization : specializations) {
       for (int i = 0; i < specialization.second; ++i)
         fileOut << "template <>\n";
-      fileOut << "const char* " << specialization.first << "::DNAType() {\n  return \"" << specialization.first
-              << "\";\n}\n";
+      fileOut << "std::string_view " << specialization.first << "::DNAType() {\n  return \"" << specialization.first
+              << "\"sv;\n}\n";
     }
     fileOut << "\n\n";
 
diff --git a/include/athena/DNA.hpp b/include/athena/DNA.hpp
index 0927e63..2985f8e 100644
--- a/include/athena/DNA.hpp
+++ b/include/athena/DNA.hpp
@@ -17,6 +17,8 @@
 #include "athena/IStreamReader.hpp"
 #include "athena/IStreamWriter.hpp"
 
+using namespace std::literals;
+
 namespace athena::io {
 
 /**
@@ -127,7 +129,7 @@ struct DNAV : DNA<DNAE> {
   virtual void read(athena::io::IStreamReader& r) = 0;
   virtual void write(athena::io::IStreamWriter& w) const = 0;
   virtual void binarySize(size_t& s) const = 0;
-  virtual const char* DNATypeV() const = 0;
+  virtual std::string_view DNATypeV() const = 0;
 };
 
 template <Endian DNAE>
diff --git a/include/athena/DNAOp.hpp b/include/athena/DNAOp.hpp
index f777863..2aa19d1 100644
--- a/include/athena/DNAOp.hpp
+++ b/include/athena/DNAOp.hpp
@@ -15,20 +15,20 @@
 namespace athena::io {
 
 struct PropId {
-  const char* name = nullptr;
+  std::string_view name;
   uint32_t rcrc32 = 0xffffffff;
   uint64_t crc64 = 0x0;
   template <class T>
   constexpr T opget() const;
   constexpr PropId() = default;
-  constexpr explicit PropId(const char* name, uint32_t rcrc32, uint64_t crc64)
+  constexpr explicit PropId(std::string_view name, uint32_t rcrc32, uint64_t crc64)
   : name(name), rcrc32(rcrc32), crc64(crc64) {}
-  constexpr explicit PropId(const char* name)
+  constexpr explicit PropId(std::string_view name)
   : name(name)
-  , rcrc32(athena::checksums::literals::rcrc32_rec(0xFFFFFFFF, name))
-  , crc64(athena::checksums::literals::crc64_rec(0xFFFFFFFFFFFFFFFF, name)) {}
-  constexpr PropId(const char* name, uint32_t rcrc32)
-  : name(name), rcrc32(rcrc32), crc64(athena::checksums::literals::crc64_rec(0xFFFFFFFFFFFFFFFF, name)) {}
+  , rcrc32(athena::checksums::literals::rcrc32_rec(0xFFFFFFFF, name.data()))
+  , crc64(athena::checksums::literals::crc64_rec(0xFFFFFFFFFFFFFFFF, name.data())) {}
+  constexpr PropId(std::string_view name, uint32_t rcrc32)
+  : name(name), rcrc32(rcrc32), crc64(athena::checksums::literals::crc64_rec(0xFFFFFFFFFFFFFFFF, name.data())) {}
 };
 
 template <>
@@ -628,7 +628,7 @@ struct ReadYaml {
     if (auto __v = r.enterSubVector(id.name, _count)) {
       vector.reserve(_count);
       for (size_t i = 0; i < _count; ++i)
-        vector.push_back(r.readBool(nullptr));
+        vector.push_back(r.readBool());
     }
     /* Horrible reference abuse (but it works) */
     const_cast<S&>(count) = vector.size();
@@ -733,7 +733,7 @@ struct WriteYaml {
     /* libc++ specializes vector<bool> as a bitstream */
     if (auto __v = w.enterSubVector(id.name))
       for (const T& v : vector)
-        w.writeBool(nullptr, v);
+        w.writeBool(v);
   }
   static void Do(const PropId& id, std::unique_ptr<atUint8[]>& buf, size_t count, StreamT& w) {
     w.writeUBytes(id.name, buf, count);
@@ -944,7 +944,7 @@ void __BinarySizeProp64(const T& obj, size_t& s) {
   }                                                                                                                    \
   template <class Op>                                                                                                  \
   void Enumerate(typename Op::StreamT& s);                                                                             \
-  static const char* DNAType();
+  static std::string_view DNAType();
 
 #define AT_DECL_DNA                                                                                                    \
   AT_DECL_DNA_DO                                                                                                       \
@@ -985,7 +985,7 @@ void __BinarySizeProp64(const T& obj, size_t& s) {
   void read(athena::io::IStreamReader& r) override { athena::io::__Read(*this, r); }                                   \
   void write(athena::io::IStreamWriter& w) const override { athena::io::__Write(*this, w); }                           \
   void binarySize(size_t& s) const override { athena::io::__BinarySize(*this, s); }                                    \
-  const char* DNATypeV() const override { return DNAType(); }
+  std::string_view DNATypeV() const override { return DNAType(); }
 
 #define AT_DECL_DNAV_NO_TYPE                                                                                           \
   AT_DECL_DNA_DO                                                                                                       \
@@ -1055,7 +1055,7 @@ void __BinarySizeProp64(const T& obj, size_t& s) {
   void Enumerate(typename Op::StreamT& s);                                                                             \
   template <class Op>                                                                                                  \
   bool Lookup(uint64_t hash, typename Op::StreamT& s);                                                                 \
-  static const char* DNAType();                                                                                        \
+  static std::string_view DNAType();                                                                                   \
   void read(athena::io::IStreamReader& r) { athena::io::__Read(*this, r); }                                            \
   void write(athena::io::IStreamWriter& w) const { athena::io::__Write(*this, w); }                                    \
   void binarySize(size_t& s) const { athena::io::__BinarySize(*this, s); }                                             \
diff --git a/include/athena/DNAYaml.hpp b/include/athena/DNAYaml.hpp
index 4713b14..034f369 100644
--- a/include/athena/DNAYaml.hpp
+++ b/include/athena/DNAYaml.hpp
@@ -12,12 +12,12 @@
 namespace athena::io {
 
 template <class T>
-const char* __GetDNAName(const T& dna, std::enable_if_t<athena::io::__IsDNAVRecord_v<T>>* = nullptr) {
+inline std::string_view __GetDNAName(const T& dna, std::enable_if_t<athena::io::__IsDNAVRecord_v<T>>* = nullptr) {
   return dna.DNATypeV();
 }
 
 template <class T>
-const char* __GetDNAName(const T& dna, std::enable_if_t<!athena::io::__IsDNAVRecord_v<T>>* = nullptr) {
+inline std::string_view __GetDNAName(const T& dna, std::enable_if_t<!athena::io::__IsDNAVRecord_v<T>>* = nullptr) {
   return dna.DNAType();
 }
 
diff --git a/include/athena/YAMLCommon.hpp b/include/athena/YAMLCommon.hpp
index 2353c21..5966d01 100644
--- a/include/athena/YAMLCommon.hpp
+++ b/include/athena/YAMLCommon.hpp
@@ -27,16 +27,16 @@ struct YAMLNode {
 
   YAMLNode(yaml_node_type_t type) : m_type(type) {}
 
-  const YAMLNode* findMapChild(std::string_view key) const {
+  YAMLNode* findMapChild(std::string_view key) const {
     for (const auto& item : m_mapChildren)
-      if (!item.first.compare(key))
+      if (item.first == key)
         return item.second.get();
     return nullptr;
   }
 
   void assignMapChild(std::string_view key, std::unique_ptr<YAMLNode>&& node) {
     for (auto& item : m_mapChildren)
-      if (!item.first.compare(key)) {
+      if (item.first == key) {
         item.second = std::move(node);
         return;
       }
diff --git a/include/athena/YAMLDocReader.hpp b/include/athena/YAMLDocReader.hpp
index af0f901..ed793cd 100644
--- a/include/athena/YAMLDocReader.hpp
+++ b/include/athena/YAMLDocReader.hpp
@@ -31,8 +31,8 @@ public:
 
   bool parse(athena::io::IStreamReader* reader);
 
-  bool ClassTypeOperation(std::function<bool(const char* dnaType)> func);
-  bool ValidateClassType(const char* expectedType);
+  bool ClassTypeOperation(std::function<bool(std::string_view dnaType)> func);
+  bool ValidateClassType(std::string_view expectedType);
 
   const YAMLNode* getRootNode() const { return m_rootNode.get(); }
   const YAMLNode* getCurNode() const { return m_subStack.empty() ? nullptr : m_subStack.back(); }
@@ -59,10 +59,10 @@ public:
   };
   friend class RecordRAII;
 
-  RecordRAII enterSubRecord(const char* name);
+  RecordRAII enterSubRecord(std::string_view name = {});
 
   template <class T>
-  void enumerate(const char* name, T& record, std::enable_if_t<__IsDNARecord_v<T>>* = nullptr) {
+  void enumerate(std::string_view name, T& record, std::enable_if_t<__IsDNARecord_v<T>>* = nullptr) {
     if (auto rec = enterSubRecord(name))
       record.read(*this);
   }
@@ -82,10 +82,11 @@ public:
   };
   friend class VectorRAII;
 
-  VectorRAII enterSubVector(const char* name, size_t& countOut);
+  VectorRAII enterSubVector(std::string_view name, size_t& countOut);
+  VectorRAII enterSubVector(size_t& countOut) { return enterSubVector({}, countOut); }
 
   template <class T>
-  size_t enumerate(const char* name, std::vector<T>& vector,
+  size_t enumerate(std::string_view name, std::vector<T>& vector,
                    std::enable_if_t<!std::is_arithmetic_v<T> && !std::is_same_v<T, atVec2f> &&
                                     !std::is_same_v<T, atVec3f> && !std::is_same_v<T, atVec4f>>* = nullptr) {
     size_t countOut;
@@ -94,7 +95,7 @@ public:
       vector.reserve(countOut);
       for (size_t i = 0; i < countOut; ++i) {
         vector.emplace_back();
-        if (auto rec = enterSubRecord(nullptr))
+        if (auto rec = enterSubRecord())
           vector.back().read(*this);
       }
     }
@@ -102,7 +103,7 @@ public:
   }
 
   template <class T>
-  size_t enumerate(const char* name, std::vector<T>& vector,
+  size_t enumerate(std::string_view name, std::vector<T>& vector,
                    std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, atVec2f> ||
                                     std::is_same_v<T, atVec3f> || std::is_same_v<T, atVec4f>>* = nullptr) {
     size_t countOut;
@@ -116,53 +117,53 @@ public:
   }
 
   template <class T>
-  size_t enumerate(const char* name, std::vector<T>& vector, std::function<void(YAMLDocReader&, T&)> readf) {
+  size_t enumerate(std::string_view name, std::vector<T>& vector, std::function<void(YAMLDocReader&, T&)> readf) {
     size_t countOut;
     if (auto v = enterSubVector(name, countOut)) {
       vector.clear();
       vector.reserve(countOut);
       for (size_t i = 0; i < countOut; ++i) {
         vector.emplace_back();
-        if (auto rec = enterSubRecord(nullptr))
+        if (auto rec = enterSubRecord())
           readf(*this, vector.back());
       }
     }
     return countOut;
   }
 
-  bool hasVal(const char* name) const {
+  bool hasVal(std::string_view name) const {
     if (m_subStack.size()) {
       const YAMLNode* mnode = m_subStack.back();
-      if (mnode->m_type == YAML_MAPPING_NODE && name)
+      if (mnode->m_type == YAML_MAPPING_NODE && !name.empty())
         for (const auto& item : mnode->m_mapChildren)
-          if (!item.first.compare(name))
+          if (item.first == name)
             return true;
     }
     return false;
   }
 
   template <typename RETURNTYPE>
-  RETURNTYPE readVal(const char* name);
-  bool readBool(const char* name);
-  atInt8 readByte(const char* name);
-  atUint8 readUByte(const char* name);
-  atInt16 readInt16(const char* name);
-  atUint16 readUint16(const char* name);
-  atInt32 readInt32(const char* name);
-  atUint32 readUint32(const char* name);
-  atInt64 readInt64(const char* name);
-  atUint64 readUint64(const char* name);
-  float readFloat(const char* name);
-  double readDouble(const char* name);
-  atVec2f readVec2f(const char* name);
-  atVec3f readVec3f(const char* name);
-  atVec4f readVec4f(const char* name);
-  atVec2d readVec2d(const char* name);
-  atVec3d readVec3d(const char* name);
-  atVec4d readVec4d(const char* name);
-  std::unique_ptr<atUint8[]> readUBytes(const char* name);
-  std::string readString(const char* name);
-  std::wstring readWString(const char* name);
+  RETURNTYPE readVal(std::string_view name = {});
+  bool readBool(std::string_view name = {});
+  atInt8 readByte(std::string_view name = {});
+  atUint8 readUByte(std::string_view name = {});
+  atInt16 readInt16(std::string_view name = {});
+  atUint16 readUint16(std::string_view name = {});
+  atInt32 readInt32(std::string_view name = {});
+  atUint32 readUint32(std::string_view name = {});
+  atInt64 readInt64(std::string_view name = {});
+  atUint64 readUint64(std::string_view name = {});
+  float readFloat(std::string_view name = {});
+  double readDouble(std::string_view name = {});
+  atVec2f readVec2f(std::string_view name = {});
+  atVec3f readVec3f(std::string_view name = {});
+  atVec4f readVec4f(std::string_view name = {});
+  atVec2d readVec2d(std::string_view name = {});
+  atVec3d readVec3d(std::string_view name = {});
+  atVec4d readVec4d(std::string_view name = {});
+  std::unique_ptr<atUint8[]> readUBytes(std::string_view name = {});
+  std::string readString(std::string_view name = {});
+  std::wstring readWString(std::string_view name = {});
 };
 
 } // namespace athena::io
diff --git a/include/athena/YAMLDocWriter.hpp b/include/athena/YAMLDocWriter.hpp
index 47d0cdb..bac44d9 100644
--- a/include/athena/YAMLDocWriter.hpp
+++ b/include/athena/YAMLDocWriter.hpp
@@ -20,7 +20,8 @@ class YAMLDocWriter {
   void _leaveSubVector();
 
 public:
-  explicit YAMLDocWriter(const char* classType, athena::io::IStreamReader* reader = nullptr);
+  explicit YAMLDocWriter(std::string_view classType, athena::io::IStreamReader* reader = nullptr);
+  explicit YAMLDocWriter(athena::io::IStreamReader* reader = nullptr) : YAMLDocWriter({}, reader) {}
   ~YAMLDocWriter();
 
   yaml_emitter_t* getEmitter() { return &m_emitter; }
@@ -44,10 +45,10 @@ public:
   };
   friend class RecordRAII;
 
-  RecordRAII enterSubRecord(const char* name);
+  RecordRAII enterSubRecord(std::string_view name = {});
 
   template <class T>
-  void enumerate(const char* name, T& record, std::enable_if_t<__IsDNARecord_v<T>>* = nullptr) {
+  void enumerate(std::string_view name, T& record, std::enable_if_t<__IsDNARecord_v<T>>* = nullptr) {
     if (auto rec = enterSubRecord(name))
       record.write(*this);
   }
@@ -67,64 +68,90 @@ public:
   };
   friend class VectorRAII;
 
-  VectorRAII enterSubVector(const char* name);
+  VectorRAII enterSubVector(std::string_view name = {});
 
   template <class T>
   void
-  enumerate(const char* name, const std::vector<T>& vector,
+  enumerate(std::string_view name, const std::vector<T>& vector,
             std::enable_if_t<!std::is_arithmetic_v<T> && !std::is_same_v<T, atVec2f> && !std::is_same_v<T, atVec3f> &&
                              !std::is_same_v<T, atVec4f> && !std::is_same_v<T, atVec2d> &&
                              !std::is_same_v<T, atVec3d> && !std::is_same_v<T, atVec4d>>* = nullptr) {
     if (auto v = enterSubVector(name))
       for (const T& item : vector)
-        if (auto rec = enterSubRecord(nullptr))
+        if (auto rec = enterSubRecord())
           item.write(*this);
   }
 
   template <class T>
-  void enumerate(const char* name, const std::vector<T>& vector,
+  void enumerate(std::string_view name, const std::vector<T>& vector,
                  std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, atVec2f> || std::is_same_v<T, atVec3f> ||
                                   std::is_same_v<T, atVec4f> || std::is_same_v<T, atVec2d> ||
                                   std::is_same_v<T, atVec3d> || std::is_same_v<T, atVec4d>>* = nullptr) {
     if (auto v = enterSubVector(name))
       for (T item : vector)
-        writeVal<T>(nullptr, item);
+        writeVal<T>(item);
   }
 
   template <class T>
-  void enumerate(const char* name, const std::vector<T>& vector, std::function<void(YAMLDocWriter&, const T&)> writef) {
+  void enumerate(std::string_view name, const std::vector<T>& vector, std::function<void(YAMLDocWriter&, const T&)> writef) {
     if (auto v = enterSubVector(name))
       for (const T& item : vector)
-        if (auto rec = enterSubRecord(nullptr))
+        if (auto rec = enterSubRecord())
           writef(*this, item);
   }
 
   template <typename INTYPE>
-  void writeVal(const char* name, const INTYPE& val);
+  void writeVal(std::string_view name, const INTYPE& val);
   template <typename INTYPE>
-  void writeVal(const char* name, const INTYPE& val, size_t byteCount);
-  void writeBool(const char* name, const bool& val);
-  void writeByte(const char* name, const atInt8& val);
-  void writeUByte(const char* name, const atUint8& val);
-  void writeInt16(const char* name, const atInt16& val);
-  void writeUint16(const char* name, const atUint16& val);
-  void writeInt32(const char* name, const atInt32& val);
-  void writeUint32(const char* name, const atUint32& val);
-  void writeInt64(const char* name, const atInt64& val);
-  void writeUint64(const char* name, const atUint64& val);
-  void writeFloat(const char* name, const float& val);
-  void writeDouble(const char* name, const double& val);
-  void writeVec2f(const char* name, const atVec2f& val);
-  void writeVec3f(const char* name, const atVec3f& val);
-  void writeVec4f(const char* name, const atVec4f& val);
-  void writeVec2d(const char* name, const atVec2d& val);
-  void writeVec3d(const char* name, const atVec3d& val);
-  void writeVec4d(const char* name, const atVec4d& val);
-  void writeUBytes(const char* name, const std::unique_ptr<atUint8[]>& val, size_t byteCount);
-  void writeString(const char* name, std::string_view val);
-  void writeWString(const char* name, std::wstring_view val);
-  void writeU16String(const char* name, std::u16string_view val);
-  void writeU32String(const char* name, std::u32string_view val);
+  void writeVal(const INTYPE& val) { writeVal<INTYPE>(std::string_view{}, val); }
+  template <typename INTYPE>
+  void writeVal(std::string_view name, const INTYPE& val, size_t byteCount);
+  template <typename INTYPE>
+  void writeVal(const INTYPE& val, size_t byteCount) { writeVal<INTYPE>(std::string_view{}, val, byteCount); }
+  void writeBool(std::string_view name, const bool& val);
+  void writeBool(const bool& val) { writeBool({}, val); }
+  void writeByte(std::string_view name, const atInt8& val);
+  void writeByte(const atInt8& val) { writeByte({}, val); }
+  void writeUByte(std::string_view name, const atUint8& val);
+  void writeUByte(const atUint8& val) { writeUByte({}, val); }
+  void writeInt16(std::string_view name, const atInt16& val);
+  void writeInt16(const atInt16& val) { writeInt16({}, val); }
+  void writeUint16(std::string_view name, const atUint16& val);
+  void writeUint16(const atUint16& val) { writeUint16({}, val); }
+  void writeInt32(std::string_view name, const atInt32& val);
+  void writeInt32(const atInt32& val) { writeInt32({}, val); }
+  void writeUint32(std::string_view name, const atUint32& val);
+  void writeUint32(const atUint32& val) { writeUint32({}, val); }
+  void writeInt64(std::string_view name, const atInt64& val);
+  void writeInt64(const atInt64& val) { writeInt64({}, val); }
+  void writeUint64(std::string_view name, const atUint64& val);
+  void writeUint64(const atUint64& val) { writeUint64({}, val); }
+  void writeFloat(std::string_view name, const float& val);
+  void writeFloat(const float& val) { writeFloat({}, val); }
+  void writeDouble(std::string_view name, const double& val);
+  void writeDouble(const double& val) { writeDouble({}, val); }
+  void writeVec2f(std::string_view name, const atVec2f& val);
+  void writeVec2f(const atVec2f& val) { writeVec2f({}, val); }
+  void writeVec3f(std::string_view name, const atVec3f& val);
+  void writeVec3f(const atVec3f& val) { writeVec3f({}, val); }
+  void writeVec4f(std::string_view name, const atVec4f& val);
+  void writeVec4f(const atVec4f& val) { writeVec4f({}, val); }
+  void writeVec2d(std::string_view name, const atVec2d& val);
+  void writeVec2d(const atVec2d& val) { writeVec2d({}, val); }
+  void writeVec3d(std::string_view name, const atVec3d& val);
+  void writeVec3d(const atVec3d& val) { writeVec3d({}, val); }
+  void writeVec4d(std::string_view name, const atVec4d& val);
+  void writeVec4d(const atVec4d& val) { writeVec4d({}, val); }
+  void writeUBytes(std::string_view name, const std::unique_ptr<atUint8[]>& val, size_t byteCount);
+  void writeUBytes(const std::unique_ptr<atUint8[]>& val, size_t byteCount) { writeUBytes({}, val, byteCount); }
+  void writeString(std::string_view name, std::string_view val);
+  void writeString(std::string_view val) { writeString({}, val); }
+  void writeWString(std::string_view name, std::wstring_view val);
+  void writeWString(std::wstring_view val) { writeWString({}, val); }
+  void writeU16String(std::string_view name, std::u16string_view val);
+  void writeU16String(std::u16string_view val) { writeU16String({}, val); }
+  void writeU32String(std::string_view name, std::u32string_view val);
+  void writeU32String(std::u32string_view val) { writeU32String({}, val); }
 
   void setStyle(YAMLNodeStyle s);
 };
diff --git a/src/athena/DNAYaml.cpp b/src/athena/DNAYaml.cpp
index f68c2b0..190f3e7 100644
--- a/src/athena/DNAYaml.cpp
+++ b/src/athena/DNAYaml.cpp
@@ -6,6 +6,7 @@
 #include "athena/YAMLCommon.hpp"
 
 namespace athena::io {
+using namespace std::literals;
 
 template <>
 bool NodeToVal(const YAMLNode* node) {
@@ -344,26 +345,26 @@ std::unique_ptr<YAMLNode> ValToNode(std::u32string_view val) {
   return ret;
 }
 
-static const char* ErrorString(yaml_error_type_t errt) {
+static std::string_view ErrorString(yaml_error_type_t errt) {
   switch (errt) {
   case YAML_NO_ERROR:
-    return "No Error";
+    return "No Error"sv;
   case YAML_MEMORY_ERROR:
-    return "Memory Error";
+    return "Memory Error"sv;
   case YAML_READER_ERROR:
-    return "Reader Error";
+    return "Reader Error"sv;
   case YAML_SCANNER_ERROR:
-    return "Scanner Error";
+    return "Scanner Error"sv;
   case YAML_PARSER_ERROR:
-    return "Parser Error";
+    return "Parser Error"sv;
   case YAML_COMPOSER_ERROR:
-    return "Composer Error";
+    return "Composer Error"sv;
   case YAML_WRITER_ERROR:
-    return "Writer Error";
+    return "Writer Error"sv;
   case YAML_EMITTER_ERROR:
-    return "Emitter Error";
+    return "Emitter Error"sv;
   }
-  return "Unknown Error";
+  return "Unknown Error"sv;
 }
 
 void HandleYAMLParserError(yaml_parser_t* parser) {
@@ -403,7 +404,7 @@ int YAMLAthenaWriter(athena::io::IStreamWriter* writer, unsigned char* buffer, s
   return 1;
 }
 
-YAMLDocWriter::YAMLDocWriter(const char* classType, athena::io::IStreamReader* reader) {
+YAMLDocWriter::YAMLDocWriter(std::string_view classType, athena::io::IStreamReader* reader) {
   if (!yaml_emitter_initialize(&m_emitter)) {
     HandleYAMLEmitterError(&m_emitter);
     return;
@@ -422,7 +423,7 @@ YAMLDocWriter::YAMLDocWriter(const char* classType, athena::io::IStreamReader* r
   }
 
   m_subStack.emplace_back(m_rootNode.get());
-  if (classType) {
+  if (!classType.empty()) {
     auto classVal = std::make_unique<YAMLNode>(YAML_SCALAR_NODE);
     classVal->m_scalarString.assign(classType);
     m_rootNode->assignMapChild("DNAType", std::move(classVal));
@@ -467,13 +468,13 @@ bool YAMLDocWriter::finish(athena::io::IStreamWriter* fout) {
   return true;
 }
 
-YAMLDocWriter::RecordRAII YAMLDocWriter::enterSubRecord(const char* name) {
+YAMLDocWriter::RecordRAII YAMLDocWriter::enterSubRecord(std::string_view name) {
   YAMLNode* curSub = m_subStack.back();
   if (curSub->m_type != YAML_MAPPING_NODE && curSub->m_type != YAML_SEQUENCE_NODE)
     return {};
   YAMLNode* newNode = new YAMLNode(YAML_MAPPING_NODE);
   if (curSub->m_type == YAML_MAPPING_NODE)
-    curSub->assignMapChild(name ? name : std::string_view{}, std::unique_ptr<YAMLNode>(newNode));
+    curSub->assignMapChild(!name.empty() ? name : std::string_view{}, std::unique_ptr<YAMLNode>(newNode));
   else if (curSub->m_type == YAML_SEQUENCE_NODE)
     curSub->m_seqChildren.emplace_back(newNode);
   m_subStack.push_back(newNode);
@@ -502,13 +503,13 @@ void YAMLDocWriter::_leaveSubRecord() {
   }
 }
 
-YAMLDocWriter::VectorRAII YAMLDocWriter::enterSubVector(const char* name) {
+YAMLDocWriter::VectorRAII YAMLDocWriter::enterSubVector(std::string_view name) {
   YAMLNode* curSub = m_subStack.back();
   if (curSub->m_type != YAML_MAPPING_NODE && curSub->m_type != YAML_SEQUENCE_NODE)
     return {};
   YAMLNode* newNode = new YAMLNode(YAML_SEQUENCE_NODE);
   if (curSub->m_type == YAML_MAPPING_NODE)
-    curSub->assignMapChild(name ? name : std::string_view{}, std::unique_ptr<YAMLNode>(newNode));
+    curSub->assignMapChild(!name.empty() ? name : std::string_view{}, std::unique_ptr<YAMLNode>(newNode));
   else if (curSub->m_type == YAML_SEQUENCE_NODE)
     curSub->m_seqChildren.emplace_back(newNode);
   m_subStack.push_back(newNode);
@@ -521,82 +522,82 @@ void YAMLDocWriter::_leaveSubVector() {
 }
 
 template <typename INTYPE>
-void YAMLDocWriter::writeVal(const char* name, const INTYPE& val) {
+void YAMLDocWriter::writeVal(std::string_view name, const INTYPE& val) {
   YAMLNode* curSub = m_subStack.back();
   if (curSub->m_type == YAML_MAPPING_NODE)
-    curSub->assignMapChild(name ? name : std::string_view{}, std::move(ValToNode(val)));
+    curSub->assignMapChild(!name.empty() ? name : std::string_view{}, ValToNode(val));
   else if (curSub->m_type == YAML_SEQUENCE_NODE)
-    curSub->m_seqChildren.emplace_back(std::move(ValToNode(val)));
+    curSub->m_seqChildren.emplace_back(ValToNode(val));
 }
 
-template void YAMLDocWriter::writeVal<atInt8>(const char* name, const atInt8& val);
-template void YAMLDocWriter::writeVal<atUint8>(const char* name, const atUint8& val);
-template void YAMLDocWriter::writeVal<atInt16>(const char* name, const atInt16& val);
-template void YAMLDocWriter::writeVal<atUint16>(const char* name, const atUint16& val);
-template void YAMLDocWriter::writeVal<atInt32>(const char* name, const atInt32& val);
-template void YAMLDocWriter::writeVal<atUint32>(const char* name, const atUint32& val);
-template void YAMLDocWriter::writeVal<float>(const char* name, const float& val);
-template void YAMLDocWriter::writeVal<double>(const char* name, const double& val);
-template void YAMLDocWriter::writeVal<atVec3f>(const char* name, const atVec3f& val);
-template void YAMLDocWriter::writeVal<atVec4f>(const char* name, const atVec4f& val);
-template void YAMLDocWriter::writeVal<bool>(const char* name, const bool& val);
+template void YAMLDocWriter::writeVal<atInt8>(std::string_view name, const atInt8& val);
+template void YAMLDocWriter::writeVal<atUint8>(std::string_view name, const atUint8& val);
+template void YAMLDocWriter::writeVal<atInt16>(std::string_view name, const atInt16& val);
+template void YAMLDocWriter::writeVal<atUint16>(std::string_view name, const atUint16& val);
+template void YAMLDocWriter::writeVal<atInt32>(std::string_view name, const atInt32& val);
+template void YAMLDocWriter::writeVal<atUint32>(std::string_view name, const atUint32& val);
+template void YAMLDocWriter::writeVal<float>(std::string_view name, const float& val);
+template void YAMLDocWriter::writeVal<double>(std::string_view name, const double& val);
+template void YAMLDocWriter::writeVal<atVec3f>(std::string_view name, const atVec3f& val);
+template void YAMLDocWriter::writeVal<atVec4f>(std::string_view name, const atVec4f& val);
+template void YAMLDocWriter::writeVal<bool>(std::string_view name, const bool& val);
 
 template <typename INTYPE>
-void YAMLDocWriter::writeVal(const char* name, const INTYPE& val, size_t byteCount) {
+void YAMLDocWriter::writeVal(std::string_view name, const INTYPE& val, size_t byteCount) {
   YAMLNode* curSub = m_subStack.back();
   if (curSub->m_type == YAML_MAPPING_NODE)
-    curSub->assignMapChild(name ? name : std::string_view{}, std::move(ValToNode(val, byteCount)));
+    curSub->assignMapChild(!name.empty() ? name : std::string_view{}, ValToNode(val, byteCount));
   else if (curSub->m_type == YAML_SEQUENCE_NODE)
-    curSub->m_seqChildren.emplace_back(std::move(ValToNode(val, byteCount)));
+    curSub->m_seqChildren.emplace_back(ValToNode(val, byteCount));
 }
 
-void YAMLDocWriter::writeBool(const char* name, const bool& val) { writeVal<bool>(name, val); }
+void YAMLDocWriter::writeBool(std::string_view name, const bool& val) { writeVal<bool>(name, val); }
 
-void YAMLDocWriter::writeByte(const char* name, const atInt8& val) { writeVal<atInt8>(name, val); }
+void YAMLDocWriter::writeByte(std::string_view name, const atInt8& val) { writeVal<atInt8>(name, val); }
 
-void YAMLDocWriter::writeUByte(const char* name, const atUint8& val) { writeVal<atUint8>(name, val); }
+void YAMLDocWriter::writeUByte(std::string_view name, const atUint8& val) { writeVal<atUint8>(name, val); }
 
-void YAMLDocWriter::writeInt16(const char* name, const atInt16& val) { writeVal<atInt16>(name, val); }
+void YAMLDocWriter::writeInt16(std::string_view name, const atInt16& val) { writeVal<atInt16>(name, val); }
 
-void YAMLDocWriter::writeUint16(const char* name, const atUint16& val) { writeVal<atUint16>(name, val); }
+void YAMLDocWriter::writeUint16(std::string_view name, const atUint16& val) { writeVal<atUint16>(name, val); }
 
-void YAMLDocWriter::writeInt32(const char* name, const atInt32& val) { writeVal<atInt32>(name, val); }
+void YAMLDocWriter::writeInt32(std::string_view name, const atInt32& val) { writeVal<atInt32>(name, val); }
 
-void YAMLDocWriter::writeUint32(const char* name, const atUint32& val) { writeVal<atUint32>(name, val); }
+void YAMLDocWriter::writeUint32(std::string_view name, const atUint32& val) { writeVal<atUint32>(name, val); }
 
-void YAMLDocWriter::writeInt64(const char* name, const atInt64& val) { writeVal<atInt64>(name, val); }
+void YAMLDocWriter::writeInt64(std::string_view name, const atInt64& val) { writeVal<atInt64>(name, val); }
 
-void YAMLDocWriter::writeUint64(const char* name, const atUint64& val) { writeVal<atUint64>(name, val); }
+void YAMLDocWriter::writeUint64(std::string_view name, const atUint64& val) { writeVal<atUint64>(name, val); }
 
-void YAMLDocWriter::writeFloat(const char* name, const float& val) { writeVal<float>(name, val); }
+void YAMLDocWriter::writeFloat(std::string_view name, const float& val) { writeVal<float>(name, val); }
 
-void YAMLDocWriter::writeDouble(const char* name, const double& val) { writeVal<double>(name, val); }
+void YAMLDocWriter::writeDouble(std::string_view name, const double& val) { writeVal<double>(name, val); }
 
-void YAMLDocWriter::writeVec2f(const char* name, const atVec2f& val) { writeVal<atVec2f>(name, val); }
+void YAMLDocWriter::writeVec2f(std::string_view name, const atVec2f& val) { writeVal<atVec2f>(name, val); }
 
-void YAMLDocWriter::writeVec3f(const char* name, const atVec3f& val) { writeVal<atVec3f>(name, val); }
+void YAMLDocWriter::writeVec3f(std::string_view name, const atVec3f& val) { writeVal<atVec3f>(name, val); }
 
-void YAMLDocWriter::writeVec4f(const char* name, const atVec4f& val) { writeVal<atVec4f>(name, val); }
+void YAMLDocWriter::writeVec4f(std::string_view name, const atVec4f& val) { writeVal<atVec4f>(name, val); }
 
-void YAMLDocWriter::writeVec2d(const char* name, const atVec2d& val) { writeVal<atVec2d>(name, val); }
+void YAMLDocWriter::writeVec2d(std::string_view name, const atVec2d& val) { writeVal<atVec2d>(name, val); }
 
-void YAMLDocWriter::writeVec3d(const char* name, const atVec3d& val) { writeVal<atVec3d>(name, val); }
+void YAMLDocWriter::writeVec3d(std::string_view name, const atVec3d& val) { writeVal<atVec3d>(name, val); }
 
-void YAMLDocWriter::writeVec4d(const char* name, const atVec4d& val) { writeVal<atVec4d>(name, val); }
+void YAMLDocWriter::writeVec4d(std::string_view name, const atVec4d& val) { writeVal<atVec4d>(name, val); }
 
-void YAMLDocWriter::writeUBytes(const char* name, const std::unique_ptr<atUint8[]>& val, size_t byteCount) {
+void YAMLDocWriter::writeUBytes(std::string_view name, const std::unique_ptr<atUint8[]>& val, size_t byteCount) {
   writeVal<const std::unique_ptr<atUint8[]>&>(name, val, byteCount);
 }
 
-void YAMLDocWriter::writeString(const char* name, std::string_view val) { writeVal<std::string_view>(name, val); }
+void YAMLDocWriter::writeString(std::string_view name, std::string_view val) { writeVal<std::string_view>(name, val); }
 
-void YAMLDocWriter::writeWString(const char* name, std::wstring_view val) { writeVal<std::wstring_view>(name, val); }
+void YAMLDocWriter::writeWString(std::string_view name, std::wstring_view val) { writeVal<std::wstring_view>(name, val); }
 
-void YAMLDocWriter::writeU16String(const char* name, std::u16string_view val) {
+void YAMLDocWriter::writeU16String(std::string_view name, std::u16string_view val) {
   writeVal<std::u16string_view>(name, val);
 }
 
-void YAMLDocWriter::writeU32String(const char* name, std::u32string_view val) {
+void YAMLDocWriter::writeU32String(std::string_view name, std::u32string_view val) {
   writeVal<std::u32string_view>(name, val);
 }
 
@@ -711,7 +712,7 @@ bool YAMLDocReader::parse(athena::io::IStreamReader* reader) {
   return true;
 }
 
-bool YAMLDocReader::ClassTypeOperation(std::function<bool(const char* dnaType)> func) {
+bool YAMLDocReader::ClassTypeOperation(std::function<bool(std::string_view dnaType)> func) {
   yaml_event_t event;
   if (!yaml_parser_parse(&m_parser, &event)) {
     HandleYAMLParserError(&m_parser);
@@ -762,14 +763,14 @@ bool YAMLDocReader::ClassTypeOperation(std::function<bool(const char* dnaType)>
   return false;
 }
 
-bool YAMLDocReader::ValidateClassType(const char* expectedType) {
-  if (!expectedType)
+bool YAMLDocReader::ValidateClassType(std::string_view expectedType) {
+  if (expectedType.empty())
     return false;
 
-  return ClassTypeOperation([&](const char* dnaType) -> bool { return (strcmp(expectedType, dnaType) == 0); });
+  return ClassTypeOperation([&](std::string_view dnaType) { return expectedType == dnaType; });
 }
 
-YAMLDocReader::RecordRAII YAMLDocReader::enterSubRecord(const char* name) {
+YAMLDocReader::RecordRAII YAMLDocReader::enterSubRecord(std::string_view name) {
   YAMLNode* curSub = m_subStack.back();
   if (curSub->m_type == YAML_SEQUENCE_NODE) {
     int& seqIdx = m_seqTrackerStack.back();
@@ -777,11 +778,11 @@ YAMLDocReader::RecordRAII YAMLDocReader::enterSubRecord(const char* name) {
     if (m_subStack.back()->m_type == YAML_SEQUENCE_NODE)
       m_seqTrackerStack.push_back(0);
     return RecordRAII{this};
-  } else if (!name) {
+  } else if (name.empty()) {
     atError(fmt("Expected YAML sequence"));
   }
   for (const auto& item : curSub->m_mapChildren) {
-    if (!item.first.compare(name)) {
+    if (item.first == name) {
       m_subStack.push_back(item.second.get());
       if (m_subStack.back()->m_type == YAML_SEQUENCE_NODE)
         m_seqTrackerStack.push_back(0);
@@ -799,16 +800,16 @@ void YAMLDocReader::_leaveSubRecord() {
   }
 }
 
-YAMLDocReader::VectorRAII YAMLDocReader::enterSubVector(const char* name, size_t& countOut) {
+YAMLDocReader::VectorRAII YAMLDocReader::enterSubVector(std::string_view name, size_t& countOut) {
   YAMLNode* curSub = m_subStack.back();
-  if (!name && curSub->m_type == YAML_SEQUENCE_NODE) {
+  if (name.empty() && curSub->m_type == YAML_SEQUENCE_NODE) {
     m_subStack.push_back(curSub);
     m_seqTrackerStack.push_back(0);
     countOut = curSub->m_seqChildren.size();
     return VectorRAII{this};
   } else {
     for (const auto& item : curSub->m_mapChildren) {
-      if (!item.first.compare(name)) {
+      if (item.first == name) {
         YAMLNode* nextSub = item.second.get();
         if (nextSub->m_type == YAML_SEQUENCE_NODE) {
           countOut = nextSub->m_seqChildren.size();
@@ -834,7 +835,7 @@ void YAMLDocReader::_leaveSubVector() {
 }
 
 template <typename RETURNTYPE>
-RETURNTYPE YAMLDocReader::readVal(const char* name) {
+RETURNTYPE YAMLDocReader::readVal(std::string_view name) {
   if (m_subStack.size()) {
     const YAMLNode* mnode = m_subStack.back();
     if (mnode->m_type == YAML_SCALAR_NODE) {
@@ -842,75 +843,75 @@ RETURNTYPE YAMLDocReader::readVal(const char* name) {
     } else if (mnode->m_type == YAML_SEQUENCE_NODE) {
       int& seqIdx = m_seqTrackerStack.back();
       return NodeToVal<RETURNTYPE>(mnode->m_seqChildren[seqIdx++].get());
-    } else if (mnode->m_type == YAML_MAPPING_NODE && name) {
+    } else if (mnode->m_type == YAML_MAPPING_NODE && !name.empty()) {
       for (const auto& item : mnode->m_mapChildren) {
-        if (!item.first.compare(name)) {
+        if (item.first == name) {
           return NodeToVal<RETURNTYPE>(item.second.get());
         }
       }
     }
   }
-  if (name)
+  if (!name.empty())
     atWarning(fmt("Unable to find field '{}'; returning 0"), name);
   return RETURNTYPE();
 }
 
-template atInt8 YAMLDocReader::readVal<atInt8>(const char* name);
-template atUint8 YAMLDocReader::readVal<atUint8>(const char* name);
-template atInt16 YAMLDocReader::readVal<atInt16>(const char* name);
-template atUint16 YAMLDocReader::readVal<atUint16>(const char* name);
-template atInt32 YAMLDocReader::readVal<atInt32>(const char* name);
-template atUint32 YAMLDocReader::readVal<atUint32>(const char* name);
-template float YAMLDocReader::readVal<float>(const char* name);
-template double YAMLDocReader::readVal<double>(const char* name);
-template atVec3f YAMLDocReader::readVal<atVec3f>(const char* name);
-template atVec4f YAMLDocReader::readVal<atVec4f>(const char* name);
-template bool YAMLDocReader::readVal<bool>(const char* name);
+template atInt8 YAMLDocReader::readVal<atInt8>(std::string_view name);
+template atUint8 YAMLDocReader::readVal<atUint8>(std::string_view name);
+template atInt16 YAMLDocReader::readVal<atInt16>(std::string_view name);
+template atUint16 YAMLDocReader::readVal<atUint16>(std::string_view name);
+template atInt32 YAMLDocReader::readVal<atInt32>(std::string_view name);
+template atUint32 YAMLDocReader::readVal<atUint32>(std::string_view name);
+template float YAMLDocReader::readVal<float>(std::string_view name);
+template double YAMLDocReader::readVal<double>(std::string_view name);
+template atVec3f YAMLDocReader::readVal<atVec3f>(std::string_view name);
+template atVec4f YAMLDocReader::readVal<atVec4f>(std::string_view name);
+template bool YAMLDocReader::readVal<bool>(std::string_view name);
 
-bool YAMLDocReader::readBool(const char* name) { return readVal<bool>(name); }
+bool YAMLDocReader::readBool(std::string_view name) { return readVal<bool>(name); }
 
-atInt8 YAMLDocReader::readByte(const char* name) { return readVal<atInt8>(name); }
+atInt8 YAMLDocReader::readByte(std::string_view name) { return readVal<atInt8>(name); }
 
-atUint8 YAMLDocReader::readUByte(const char* name) { return readVal<atUint8>(name); }
+atUint8 YAMLDocReader::readUByte(std::string_view name) { return readVal<atUint8>(name); }
 
-atInt16 YAMLDocReader::readInt16(const char* name) { return readVal<atInt16>(name); }
+atInt16 YAMLDocReader::readInt16(std::string_view name) { return readVal<atInt16>(name); }
 
-atUint16 YAMLDocReader::readUint16(const char* name) { return readVal<atUint16>(name); }
+atUint16 YAMLDocReader::readUint16(std::string_view name) { return readVal<atUint16>(name); }
 
-atInt32 YAMLDocReader::readInt32(const char* name) { return readVal<atInt32>(name); }
+atInt32 YAMLDocReader::readInt32(std::string_view name) { return readVal<atInt32>(name); }
 
-atUint32 YAMLDocReader::readUint32(const char* name) { return readVal<atUint32>(name); }
+atUint32 YAMLDocReader::readUint32(std::string_view name) { return readVal<atUint32>(name); }
 
-atInt64 YAMLDocReader::readInt64(const char* name) { return readVal<atInt64>(name); }
+atInt64 YAMLDocReader::readInt64(std::string_view name) { return readVal<atInt64>(name); }
 
-atUint64 YAMLDocReader::readUint64(const char* name) { return readVal<atUint64>(name); }
+atUint64 YAMLDocReader::readUint64(std::string_view name) { return readVal<atUint64>(name); }
 
-float YAMLDocReader::readFloat(const char* name) { return readVal<float>(name); }
+float YAMLDocReader::readFloat(std::string_view name) { return readVal<float>(name); }
 
-double YAMLDocReader::readDouble(const char* name) { return readVal<double>(name); }
+double YAMLDocReader::readDouble(std::string_view name) { return readVal<double>(name); }
 
-atVec2f YAMLDocReader::readVec2f(const char* name) { return readVal<atVec2f>(name); }
+atVec2f YAMLDocReader::readVec2f(std::string_view name) { return readVal<atVec2f>(name); }
 
-atVec3f YAMLDocReader::readVec3f(const char* name) { return readVal<atVec3f>(name); }
-atVec4f YAMLDocReader::readVec4f(const char* name) { return readVal<atVec4f>(name); }
+atVec3f YAMLDocReader::readVec3f(std::string_view name) { return readVal<atVec3f>(name); }
+atVec4f YAMLDocReader::readVec4f(std::string_view name) { return readVal<atVec4f>(name); }
 
-atVec2d YAMLDocReader::readVec2d(const char* name) { return readVal<atVec2d>(name); }
+atVec2d YAMLDocReader::readVec2d(std::string_view name) { return readVal<atVec2d>(name); }
 
-atVec3d YAMLDocReader::readVec3d(const char* name) { return readVal<atVec3d>(name); }
+atVec3d YAMLDocReader::readVec3d(std::string_view name) { return readVal<atVec3d>(name); }
 
-atVec4d YAMLDocReader::readVec4d(const char* name) { return readVal<atVec4d>(name); }
+atVec4d YAMLDocReader::readVec4d(std::string_view name) { return readVal<atVec4d>(name); }
 
-std::unique_ptr<atUint8[]> YAMLDocReader::readUBytes(const char* name) {
+std::unique_ptr<atUint8[]> YAMLDocReader::readUBytes(std::string_view name) {
   return readVal<std::unique_ptr<atUint8[]>>(name);
 }
 
-std::string YAMLDocReader::readString(const char* name) { return readVal<std::string>(name); }
+std::string YAMLDocReader::readString(std::string_view name) { return readVal<std::string>(name); }
 
-std::wstring YAMLDocReader::readWString(const char* name) { return readVal<std::wstring>(name); }
+std::wstring YAMLDocReader::readWString(std::string_view name) { return readVal<std::wstring>(name); }
 
-static bool EmitKeyScalar(yaml_emitter_t* doc, const char* val) {
+static bool EmitKeyScalar(yaml_emitter_t* doc, std::string_view val) {
   yaml_event_t event;
-  if (!yaml_scalar_event_initialize(&event, nullptr, nullptr, (yaml_char_t*)val, strlen(val), true, true,
+  if (!yaml_scalar_event_initialize(&event, nullptr, nullptr, (yaml_char_t*)val.data(), val.size(), true, true,
                                     YAML_PLAIN_SCALAR_STYLE))
     return false;
   return yaml_emitter_emit(doc, &event) != 0;
diff --git a/src/athena/Utility.cpp b/src/athena/Utility.cpp
index 6779da1..39f66dd 100644
--- a/src/athena/Utility.cpp
+++ b/src/athena/Utility.cpp
@@ -71,7 +71,7 @@ bool parseBool(std::string_view boolean, bool* valid) {
   tolower(val);
 
   // Check for true first
-  if (!val.compare("true") || !val.compare("1") || !val.compare("yes") || !val.compare("on")) {
+  if (val == "true" || val == "1" || val == "yes" || val == "on") {
     if (valid)
       *valid = true;
 
@@ -79,7 +79,7 @@ bool parseBool(std::string_view boolean, bool* valid) {
   }
 
   // Now false
-  if (!val.compare("false") || !val.compare("0") || !val.compare("no") || !val.compare("off")) {
+  if (val == "false" || val == "0" || val == "no" || val == "off") {
     if (valid)
       *valid = true;
 
diff --git a/src/athena/WiiFile.cpp b/src/athena/WiiFile.cpp
index a83e210..db207d5 100644
--- a/src/athena/WiiFile.cpp
+++ b/src/athena/WiiFile.cpp
@@ -96,7 +96,7 @@ void WiiFile::addChild(WiiFile* file) {
     tmpName = tmpName.substr(0, tmpName.find('/'));
 
     for (atUint32 i = 0; i < m_children.size(); i++) {
-      if (!m_children[i]->filename().compare(tmpName)) {
+      if (m_children[i]->filename() == tmpName) {
         std::string newName = file->filename();
         newName = newName.substr(newName.rfind("/") + 1, newName.size() - newName.rfind("/"));
         file->setFilename(newName);
@@ -114,7 +114,7 @@ void WiiFile::addChild(WiiFile* file) {
 
 WiiFile* WiiFile::child(const std::string& name) {
   std::vector<WiiFile*>::iterator iter =
-      std::find_if(m_children.begin(), m_children.end(), [&name](WiiFile* f) { return !f->filename().compare(name); });
+      std::find_if(m_children.begin(), m_children.end(), [&name](WiiFile* f) { return f->filename() == name; });
 
   if (iter != m_children.end())
     return *iter;
diff --git a/src/athena/ZQuestFileReader.cpp b/src/athena/ZQuestFileReader.cpp
index 479ff7d..bda6125 100644
--- a/src/athena/ZQuestFileReader.cpp
+++ b/src/athena/ZQuestFileReader.cpp
@@ -41,7 +41,7 @@ ZQuestFile* ZQuestFileReader::read() {
     gameString = std::string((const char*)readBytes(0x0A).get(), 0x0A);
 
     for (size_t i = 0; i < ZQuestFile::gameStringList().size(); i++) {
-      if (!ZQuestFile::gameStringList().at(i).substr(0, 0x0A).compare(gameString)) {
+      if (ZQuestFile::gameStringList().at(i).substr(0, 0x0A) == gameString) {
         gameString = ZQuestFile::gameStringList().at(i);
         game = (ZQuestFile::Game)i;
         break;