diff --git a/libraries/libstratosphere/include/stratosphere/fs/fs_memory_management.hpp b/libraries/libstratosphere/include/stratosphere/fs/fs_memory_management.hpp
index abe362650..7084daeab 100644
--- a/libraries/libstratosphere/include/stratosphere/fs/fs_memory_management.hpp
+++ b/libraries/libstratosphere/include/stratosphere/fs/fs_memory_management.hpp
@@ -50,7 +50,7 @@ namespace ams::fs {
         std::unique_ptr<ArrayT, Deleter> MakeUnique(size_t size) {
             using T = typename std::remove_extent<ArrayT>::type;
 
-            static_assert(std::is_pod<ArrayT>::value);
+            static_assert(util::is_pod<ArrayT>::value);
             static_assert(std::is_array<ArrayT>::value);
 
             const size_t alloc_size = sizeof(T) * size;
diff --git a/libraries/libstratosphere/include/stratosphere/fs/fs_save_data_types.hpp b/libraries/libstratosphere/include/stratosphere/fs/fs_save_data_types.hpp
index 83387f837..38690d34f 100644
--- a/libraries/libstratosphere/include/stratosphere/fs/fs_save_data_types.hpp
+++ b/libraries/libstratosphere/include/stratosphere/fs/fs_save_data_types.hpp
@@ -161,7 +161,7 @@ namespace ams::fs {
 
         u8 value[Size];
     };
-    static_assert(std::is_pod<HashSalt>::value);
+    static_assert(util::is_pod<HashSalt>::value);
     static_assert(sizeof(HashSalt) == HashSalt::Size);
 
     using SaveDataHashSalt = std::optional<HashSalt>;
diff --git a/libraries/libstratosphere/include/stratosphere/fssrv/fssrv_i_file_system_creator.hpp b/libraries/libstratosphere/include/stratosphere/fssrv/fssrv_i_file_system_creator.hpp
index 9b6235980..4e8e5c99f 100644
--- a/libraries/libstratosphere/include/stratosphere/fssrv/fssrv_i_file_system_creator.hpp
+++ b/libraries/libstratosphere/include/stratosphere/fssrv/fssrv_i_file_system_creator.hpp
@@ -73,6 +73,6 @@ namespace ams::fssrv::fscreator {
         IStorageOnNcaCreator *storage_on_nca_creator;
         /* TODO: More creators. */
     };
-    static_assert(std::is_pod<FileSystemCreatorInterfaces>::value);
+    static_assert(util::is_pod<FileSystemCreatorInterfaces>::value);
 
 }
diff --git a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_aes_ctr_counter_extended_storage.hpp b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_aes_ctr_counter_extended_storage.hpp
index d1e198c85..6aff1da55 100644
--- a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_aes_ctr_counter_extended_storage.hpp
+++ b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_aes_ctr_counter_extended_storage.hpp
@@ -57,7 +57,7 @@ namespace ams::fssystem {
             };
             static_assert(sizeof(Entry)  == 0x10);
             static_assert(alignof(Entry) == 4);
-            static_assert(std::is_pod<Entry>::value);
+            static_assert(util::is_pod<Entry>::value);
         public:
             static constexpr s64 QueryHeaderStorageSize() {
                 return BucketTree::QueryHeaderStorageSize();
diff --git a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_bucket_tree.hpp b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_bucket_tree.hpp
index d01168e0b..fdf718b4d 100644
--- a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_bucket_tree.hpp
+++ b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_bucket_tree.hpp
@@ -40,7 +40,7 @@ namespace ams::fssystem {
                 void Format(s32 entry_count);
                 Result Verify() const;
             };
-            static_assert(std::is_pod<Header>::value);
+            static_assert(util::is_pod<Header>::value);
             static_assert(sizeof(Header) == 0x10);
 
             struct NodeHeader {
@@ -50,7 +50,7 @@ namespace ams::fssystem {
 
                 Result Verify(s32 node_index, size_t node_size, size_t entry_size) const;
             };
-            static_assert(std::is_pod<NodeHeader>::value);
+            static_assert(util::is_pod<NodeHeader>::value);
             static_assert(sizeof(NodeHeader) == 0x10);
 
             class ContinuousReadingInfo {
@@ -140,7 +140,7 @@ namespace ams::fssystem {
 
                     template<typename T>
                     T *Get() const {
-                        static_assert(std::is_pod<T>::value);
+                        static_assert(util::is_pod<T>::value);
                         static_assert(sizeof(T) == sizeof(NodeHeader));
                         return reinterpret_cast<T *>(this->header);
                     }
@@ -278,9 +278,9 @@ namespace ams::fssystem {
                     s64 end;
                     s64 start;
                 } info;
-                static_assert(std::is_pod<Info>::value);
+                static_assert(util::is_pod<Info>::value);
             };
-            static_assert(std::is_pod<EntrySetHeader>::value);
+            static_assert(util::is_pod<EntrySetHeader>::value);
         private:
             const BucketTree *tree;
             void *entry;
diff --git a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_bucket_tree_template_impl.hpp b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_bucket_tree_template_impl.hpp
index 1fcb6d903..03d55e42b 100644
--- a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_bucket_tree_template_impl.hpp
+++ b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_bucket_tree_template_impl.hpp
@@ -22,7 +22,7 @@ namespace ams::fssystem {
 
     template<typename EntryType>
     Result BucketTree::ScanContinuousReading(ContinuousReadingInfo *out_info, const ContinuousReadingParam<EntryType> &param) const {
-        static_assert(std::is_pod<ContinuousReadingParam<EntryType>>::value);
+        static_assert(util::is_pod<ContinuousReadingParam<EntryType>>::value);
 
         /* Validate our preconditions. */
         AMS_ASSERT(this->IsInitialized());
@@ -149,7 +149,7 @@ namespace ams::fssystem {
 
     template<typename EntryType>
     Result BucketTree::Visitor::ScanContinuousReading(ContinuousReadingInfo *out_info, s64 offset, size_t size) const {
-        static_assert(std::is_pod<EntryType>::value);
+        static_assert(util::is_pod<EntryType>::value);
         AMS_ASSERT(this->IsValid());
 
         /* Create our parameters. */
diff --git a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_indirect_storage.hpp b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_indirect_storage.hpp
index 0f35e1640..0fdde75a2 100644
--- a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_indirect_storage.hpp
+++ b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_indirect_storage.hpp
@@ -53,7 +53,7 @@ namespace ams::fssystem {
                     return offset;
                 }
             };
-            static_assert(std::is_pod<Entry>::value);
+            static_assert(util::is_pod<Entry>::value);
             static_assert(sizeof(Entry) == 0x14);
 
             struct EntryData {
@@ -67,7 +67,7 @@ namespace ams::fssystem {
                     this->storage_index = entry.storage_index;
                 }
             };
-            static_assert(std::is_pod<EntryData>::value);
+            static_assert(util::is_pod<EntryData>::value);
         private:
             struct ContinuousReadingEntry {
                 static constexpr size_t FragmentSizeMax = 4_KB;
@@ -86,7 +86,7 @@ namespace ams::fssystem {
                     return this->entry.storage_index != 0;
                 }
             };
-            static_assert(std::is_pod<ContinuousReadingEntry>::value);
+            static_assert(util::is_pod<ContinuousReadingEntry>::value);
         public:
             static constexpr s64 QueryHeaderStorageSize() {
                 return BucketTree::QueryHeaderStorageSize();
diff --git a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_nca_file_system_driver.hpp b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_nca_file_system_driver.hpp
index 10460c363..4f4d9576c 100644
--- a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_nca_file_system_driver.hpp
+++ b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_nca_file_system_driver.hpp
@@ -55,7 +55,7 @@ namespace ams::fssystem {
         DecryptAesCtrFunction decrypt_aes_ctr_external;
         bool is_plaintext_header_available;
     };
-    static_assert(std::is_pod<NcaCryptoConfiguration>::value);
+    static_assert(util::is_pod<NcaCryptoConfiguration>::value);
 
     constexpr inline bool IsInvalidKeyTypeValue(s32 key_type) {
         return key_type < 0;
diff --git a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_nca_header.hpp b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_nca_header.hpp
index e949dc976..bc3cc6cb0 100644
--- a/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_nca_header.hpp
+++ b/libraries/libstratosphere/include/stratosphere/fssystem/fssystem_nca_header.hpp
@@ -23,7 +23,7 @@ namespace ams::fssystem {
         u8 value[Size];
     };
     static_assert(sizeof(Hash) == Hash::Size);
-    static_assert(std::is_pod<Hash>::value);
+    static_assert(util::is_pod<Hash>::value);
 
     using NcaDigest = Hash;
 
@@ -70,7 +70,7 @@ namespace ams::fssystem {
             u32 reserved;
         };
         static_assert(sizeof(FsInfo) == 0x10);
-        static_assert(std::is_pod<FsInfo>::value);
+        static_assert(util::is_pod<FsInfo>::value);
 
         static constexpr u32 Magic0 = util::FourCC<'N','C','A','0'>::Code;
         static constexpr u32 Magic1 = util::FourCC<'N','C','A','1'>::Code;
@@ -124,7 +124,7 @@ namespace ams::fssystem {
         u8 GetProperKeyGeneration() const;
     };
     static_assert(sizeof(NcaHeader) == NcaHeader::Size);
-    static_assert(std::is_pod<NcaHeader>::value);
+    static_assert(util::is_pod<NcaHeader>::value);
 
     struct NcaBucketInfo {
         static constexpr size_t HeaderSize = 0x10;
@@ -132,7 +132,7 @@ namespace ams::fssystem {
         s64 size;
         u8 header[HeaderSize];
     };
-    static_assert(std::is_pod<NcaBucketInfo>::value);
+    static_assert(util::is_pod<NcaBucketInfo>::value);
 
     struct NcaPatchInfo {
         static constexpr size_t Size   = 0x40;
@@ -148,7 +148,7 @@ namespace ams::fssystem {
         bool HasIndirectTable() const;
         bool HasAesCtrExTable() const;
     };
-    static_assert(std::is_pod<NcaPatchInfo>::value);
+    static_assert(util::is_pod<NcaPatchInfo>::value);
 
     union NcaAesCtrUpperIv {
         u64 value;
@@ -157,7 +157,7 @@ namespace ams::fssystem {
             u32 secure_value;
         } part;
     };
-    static_assert(std::is_pod<NcaAesCtrUpperIv>::value);
+    static_assert(util::is_pod<NcaAesCtrUpperIv>::value);
 
     struct NcaSparseInfo {
         NcaBucketInfo bucket;
@@ -179,7 +179,7 @@ namespace ams::fssystem {
             return sparse_upper_iv;
         }
     };
-    static_assert(std::is_pod<NcaSparseInfo>::value);
+    static_assert(util::is_pod<NcaSparseInfo>::value);
 
     struct NcaFsHeader {
         static constexpr size_t Size           = 0x200;
@@ -189,7 +189,7 @@ namespace ams::fssystem {
             s64 offset;
             s64 size;
         };
-        static_assert(std::is_pod<Region>::value);
+        static_assert(util::is_pod<Region>::value);
 
         enum class FsType : u8 {
             RomFs       = 0,
@@ -221,7 +221,7 @@ namespace ams::fssystem {
                 s32 hash_layer_count;
                 Region hash_layer_region[HashLayerCountMax];
             } hierarchical_sha256_data;
-            static_assert(std::is_pod<HierarchicalSha256Data>::value);
+            static_assert(util::is_pod<HierarchicalSha256Data>::value);
 
             struct IntegrityMetaInfo {
                 static const size_t MasterHashOffset;
@@ -249,7 +249,7 @@ namespace ams::fssystem {
 
                 Hash master_hash;
             } integrity_meta_info;
-            static_assert(std::is_pod<IntegrityMetaInfo>::value);
+            static_assert(util::is_pod<IntegrityMetaInfo>::value);
 
             u8 padding[NcaPatchInfo::Offset - HashDataOffset];
         };
@@ -266,7 +266,7 @@ namespace ams::fssystem {
         u8 pad[0x88];
     };
     static_assert(sizeof(NcaFsHeader) == NcaFsHeader::Size);
-    static_assert(std::is_pod<NcaFsHeader>::value);
+    static_assert(util::is_pod<NcaFsHeader>::value);
     static_assert(offsetof(NcaFsHeader, patch_info) == NcaPatchInfo::Offset);
 
     inline constexpr const size_t NcaFsHeader::HashData::HierarchicalSha256Data::MasterHashOffset = offsetof(NcaFsHeader, hash_data.hierarchical_sha256_data.fs_data_master_hash);
diff --git a/libraries/libstratosphere/include/stratosphere/fssystem/save/fssystem_block_cache_buffered_storage.hpp b/libraries/libstratosphere/include/stratosphere/fssystem/save/fssystem_block_cache_buffered_storage.hpp
index e708fb8a9..b93ca0241 100644
--- a/libraries/libstratosphere/include/stratosphere/fssystem/save/fssystem_block_cache_buffered_storage.hpp
+++ b/libraries/libstratosphere/include/stratosphere/fssystem/save/fssystem_block_cache_buffered_storage.hpp
@@ -32,7 +32,7 @@ namespace ams::fssystem::save {
     struct FileSystemBufferManagerSet {
         IBufferManager *buffers[IntegrityMaxLayerCount];
     };
-    static_assert(std::is_pod<FileSystemBufferManagerSet>::value);
+    static_assert(util::is_pod<FileSystemBufferManagerSet>::value);
 
     class BlockCacheBufferedStorage : public ::ams::fs::IStorage {
         NON_COPYABLE(BlockCacheBufferedStorage);
@@ -54,7 +54,7 @@ namespace ams::fssystem::save {
                 uintptr_t memory_address;
                 size_t memory_size;
             };
-            static_assert(std::is_pod<CacheEntry>::value);
+            static_assert(util::is_pod<CacheEntry>::value);
 
             enum Flag : s32 {
                 Flag_KeepBurstMode = (1 << 8),
diff --git a/libraries/libstratosphere/include/stratosphere/fssystem/save/fssystem_hierarchical_integrity_verification_storage.hpp b/libraries/libstratosphere/include/stratosphere/fssystem/save/fssystem_hierarchical_integrity_verification_storage.hpp
index 1140e3641..1283a2ac6 100644
--- a/libraries/libstratosphere/include/stratosphere/fssystem/save/fssystem_hierarchical_integrity_verification_storage.hpp
+++ b/libraries/libstratosphere/include/stratosphere/fssystem/save/fssystem_hierarchical_integrity_verification_storage.hpp
@@ -31,7 +31,7 @@ namespace ams::fssystem::save {
         s32 block_order;
         u8 reserved[4];
     };
-    static_assert(std::is_pod<HierarchicalIntegrityVerificationLevelInformation>::value);
+    static_assert(util::is_pod<HierarchicalIntegrityVerificationLevelInformation>::value);
     static_assert(sizeof(HierarchicalIntegrityVerificationLevelInformation) == 0x18);
     static_assert(alignof(HierarchicalIntegrityVerificationLevelInformation) == 0x4);
 
@@ -52,7 +52,7 @@ namespace ams::fssystem::save {
             return this->info[this->max_layers - 2].size;
         }
     };
-    static_assert(std::is_pod<HierarchicalIntegrityVerificationInformation>::value);
+    static_assert(util::is_pod<HierarchicalIntegrityVerificationInformation>::value);
 
     struct HierarchicalIntegrityVerificationMetaInformation {
         u32 magic;
@@ -62,14 +62,14 @@ namespace ams::fssystem::save {
 
         /* TODO: Format */
     };
-    static_assert(std::is_pod<HierarchicalIntegrityVerificationMetaInformation>::value);
+    static_assert(util::is_pod<HierarchicalIntegrityVerificationMetaInformation>::value);
 
     struct HierarchicalIntegrityVerificationSizeSet {
         s64 control_size;
         s64 master_hash_size;
         s64 layered_hash_sizes[IntegrityMaxLayerCount - 1];
     };
-    static_assert(std::is_pod<HierarchicalIntegrityVerificationSizeSet>::value);
+    static_assert(util::is_pod<HierarchicalIntegrityVerificationSizeSet>::value);
 
     class HierarchicalIntegrityVerificationStorageControlArea {
         NON_COPYABLE(HierarchicalIntegrityVerificationStorageControlArea);
@@ -80,7 +80,7 @@ namespace ams::fssystem::save {
             struct InputParam {
                 size_t level_block_size[IntegrityMaxLayerCount - 1];
             };
-            static_assert(std::is_pod<InputParam>::value);
+            static_assert(util::is_pod<InputParam>::value);
         private:
             fs::SubStorage storage;
             HierarchicalIntegrityVerificationMetaInformation meta;
diff --git a/libraries/libstratosphere/include/stratosphere/fssystem/save/fssystem_integrity_verification_storage.hpp b/libraries/libstratosphere/include/stratosphere/fssystem/save/fssystem_integrity_verification_storage.hpp
index 13871b9fc..fbd9e8ae1 100644
--- a/libraries/libstratosphere/include/stratosphere/fssystem/save/fssystem_integrity_verification_storage.hpp
+++ b/libraries/libstratosphere/include/stratosphere/fssystem/save/fssystem_integrity_verification_storage.hpp
@@ -35,7 +35,7 @@ namespace ams::fssystem::save {
             struct BlockHash {
                 u8 hash[HashSize];
             };
-            static_assert(std::is_pod<BlockHash>::value);
+            static_assert(util::is_pod<BlockHash>::value);
         private:
             fs::SubStorage hash_storage;
             fs::SubStorage data_storage;
diff --git a/libraries/libstratosphere/source/fssystem/fssystem_bucket_tree.cpp b/libraries/libstratosphere/source/fssystem/fssystem_bucket_tree.cpp
index a8f8046e6..2927777d3 100644
--- a/libraries/libstratosphere/source/fssystem/fssystem_bucket_tree.cpp
+++ b/libraries/libstratosphere/source/fssystem/fssystem_bucket_tree.cpp
@@ -21,7 +21,7 @@ namespace ams::fssystem {
 
         using Node = impl::BucketTreeNode<const s64 *>;
         static_assert(sizeof(Node) == sizeof(BucketTree::NodeHeader));
-        static_assert(std::is_pod<Node>::value);
+        static_assert(util::is_pod<Node>::value);
 
         constexpr inline s32 NodeHeaderSize = sizeof(BucketTree::NodeHeader);
 
diff --git a/libraries/libstratosphere/source/fssystem/save/fssystem_buffered_storage.cpp b/libraries/libstratosphere/source/fssystem/save/fssystem_buffered_storage.cpp
index d776fdba9..c8e1354b1 100644
--- a/libraries/libstratosphere/source/fssystem/save/fssystem_buffered_storage.cpp
+++ b/libraries/libstratosphere/source/fssystem/save/fssystem_buffered_storage.cpp
@@ -31,7 +31,7 @@ namespace ams::fssystem::save {
                 void *buffer;
                 size_t size;
             };
-            static_assert(std::is_pod<FetchParameter>::value);
+            static_assert(util::is_pod<FetchParameter>::value);
         private:
             BufferedStorage *buffered_storage;
             std::pair<uintptr_t, size_t> memory_range;