diff --git a/Source/Core/Core/IOS/ES/ES.cpp b/Source/Core/Core/IOS/ES/ES.cpp
@@ -26,10 +26,12 @@
 #include "Core/IOS/VersionInfo.h"
 #include "DiscIO/Enums.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
+{
+namespace
 {
 // Title to launch after IOS has been reset and reloaded (similar to /sys/launch.sys).
-static u64 s_title_to_launch;
+u64 s_title_to_launch;
 
 struct DirectoryToCreate
 {
@@ -52,8 +54,9 @@ constexpr std::array<DirectoryToCreate, 9> s_directories_to_create = {{
     {"/meta", 0, public_modes, SYSMENU_UID, SYSMENU_GID},
     {"/wfs", 0, {FS::Mode::ReadWrite, FS::Mode::None, FS::Mode::None}, PID_UNKNOWN, PID_UNKNOWN},
 }};
+}  // namespace
 
-ES::ES(Kernel& ios, const std::string& device_name) : Device(ios, device_name)
+ESDevice::ESDevice(Kernel& ios, const std::string& device_name) : Device(ios, device_name)
 {
   for (const auto& directory : s_directories_to_create)
   {
@@ -117,7 +120,7 @@ void TitleContext::Update(const IOS::ES::TMDReader& tmd_, const IOS::ES::TicketR
   }
 }
 
-IPCCommandResult ES::GetTitleDirectory(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetTitleDirectory(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 1))
     return GetDefaultReply(ES_EINVAL);
@@ -132,15 +135,15 @@ IPCCommandResult ES::GetTitleDirectory(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-ReturnCode ES::GetTitleId(u64* title_id) const
+ReturnCode ESDevice::GetTitleId(u64* title_id) const
 {
   if (!m_title_context.active)
     return ES_EINVAL;
   *title_id = m_title_context.tmd.GetTitleId();
   return IPC_SUCCESS;
 }
 
-IPCCommandResult ES::GetTitleId(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetTitleId(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(0, 1))
     return GetDefaultReply(ES_EINVAL);
@@ -193,7 +196,7 @@ static ReturnCode CheckIsAllowedToSetUID(Kernel& kernel, const u32 caller_uid,
   return ES_EINVAL;
 }
 
-IPCCommandResult ES::SetUID(u32 uid, const IOCtlVRequest& request)
+IPCCommandResult ESDevice::SetUID(u32 uid, const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 0) || request.in_vectors[0].size != 8)
     return GetDefaultReply(ES_EINVAL);
@@ -220,7 +223,7 @@ IPCCommandResult ES::SetUID(u32 uid, const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-bool ES::LaunchTitle(u64 title_id, bool skip_reload)
+bool ESDevice::LaunchTitle(u64 title_id, bool skip_reload)
 {
   m_title_context.Clear();
   INFO_LOG_FMT(IOS_ES, "ES_Launch: Title context changed: (none)");
@@ -248,7 +251,7 @@ bool ES::LaunchTitle(u64 title_id, bool skip_reload)
   return LaunchPPCTitle(title_id, skip_reload);
 }
 
-bool ES::LaunchIOS(u64 ios_title_id)
+bool ESDevice::LaunchIOS(u64 ios_title_id)
 {
   // A real Wii goes through several steps before getting to MIOS.
   //
@@ -286,7 +289,7 @@ bool ES::LaunchIOS(u64 ios_title_id)
   return m_ios.BootIOS(ios_title_id);
 }
 
-bool ES::LaunchPPCTitle(u64 title_id, bool skip_reload)
+bool ESDevice::LaunchPPCTitle(u64 title_id, bool skip_reload)
 {
   const IOS::ES::TMDReader tmd = FindInstalledTMD(title_id);
   const IOS::ES::TicketReader ticket = FindSignedTicket(title_id);
@@ -336,7 +339,7 @@ bool ES::LaunchPPCTitle(u64 title_id, bool skip_reload)
   return m_ios.BootstrapPPC(GetContentPath(tmd.GetTitleId(), content));
 }
 
-void ES::Context::DoState(PointerWrap& p)
+void ESDevice::Context::DoState(PointerWrap& p)
 {
   p.Do(uid);
   p.Do(gid);
@@ -346,7 +349,7 @@ void ES::Context::DoState(PointerWrap& p)
   p.Do(ipc_fd);
 }
 
-void ES::DoState(PointerWrap& p)
+void ESDevice::DoState(PointerWrap& p)
 {
   Device::DoState(p);
 
@@ -365,19 +368,19 @@ void ES::DoState(PointerWrap& p)
     context.DoState(p);
 }
 
-ES::ContextArray::iterator ES::FindActiveContext(s32 fd)
+ESDevice::ContextArray::iterator ESDevice::FindActiveContext(s32 fd)
 {
   return std::find_if(m_contexts.begin(), m_contexts.end(),
                       [fd](const auto& context) { return context.ipc_fd == fd && context.active; });
 }
 
-ES::ContextArray::iterator ES::FindInactiveContext()
+ESDevice::ContextArray::iterator ESDevice::FindInactiveContext()
 {
   return std::find_if(m_contexts.begin(), m_contexts.end(),
                       [](const auto& context) { return !context.active; });
 }
 
-IPCCommandResult ES::Open(const OpenRequest& request)
+IPCCommandResult ESDevice::Open(const OpenRequest& request)
 {
   auto context = FindInactiveContext();
   if (context == m_contexts.end())
@@ -390,7 +393,7 @@ IPCCommandResult ES::Open(const OpenRequest& request)
   return Device::Open(request);
 }
 
-IPCCommandResult ES::Close(u32 fd)
+IPCCommandResult ESDevice::Close(u32 fd)
 {
   auto context = FindActiveContext(fd);
   if (context == m_contexts.end())
@@ -404,7 +407,7 @@ IPCCommandResult ES::Close(u32 fd)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::IOCtlV(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::IOCtlV(const IOCtlVRequest& request)
 {
   DEBUG_LOG_FMT(IOS_ES, "{} ({:#x})", GetDeviceName(), request.request);
   auto context = FindActiveContext(request.fd);
@@ -567,7 +570,7 @@ IPCCommandResult ES::IOCtlV(const IOCtlVRequest& request)
   }
 }
 
-IPCCommandResult ES::GetConsumption(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetConsumption(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 2))
     return GetDefaultReply(ES_EINVAL);
@@ -578,7 +581,7 @@ IPCCommandResult ES::GetConsumption(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::Launch(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::Launch(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(2, 0))
     return GetDefaultReply(ES_EINVAL);
@@ -608,7 +611,7 @@ IPCCommandResult ES::Launch(const IOCtlVRequest& request)
   return GetNoReply();
 }
 
-IPCCommandResult ES::LaunchBC(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::LaunchBC(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(0, 0))
     return GetDefaultReply(ES_EINVAL);
@@ -627,7 +630,7 @@ IPCCommandResult ES::LaunchBC(const IOCtlVRequest& request)
 // This is technically an ioctlv in IOS's ES, but it is an internal API which cannot be
 // used from the PowerPC (for unpatched and up-to-date IOSes anyway).
 // So we block access to it from the IPC interface.
-IPCCommandResult ES::DIVerify(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::DIVerify(const IOCtlVRequest& request)
 {
   return GetDefaultReply(ES_EINVAL);
 }
@@ -656,7 +659,7 @@ static ReturnCode WriteTmdForDiVerify(FS::FileSystem* fs, const IOS::ES::TMDRead
   return FS::ConvertResult(fs->Rename(PID_KERNEL, PID_KERNEL, temp_path, tmd_path));
 }
 
-ReturnCode ES::DIVerify(const IOS::ES::TMDReader& tmd, const IOS::ES::TicketReader& ticket)
+ReturnCode ESDevice::DIVerify(const IOS::ES::TMDReader& tmd, const IOS::ES::TicketReader& ticket)
 {
   m_title_context.Clear();
   INFO_LOG_FMT(IOS_ES, "ES_DIVerify: Title context changed: (none)");
@@ -696,8 +699,8 @@ ReturnCode ES::DIVerify(const IOS::ES::TMDReader& tmd, const IOS::ES::TicketRead
       fs->SetMetadata(0, data_dir, m_ios.GetUidForPPC(), m_ios.GetGidForPPC(), 0, data_dir_modes));
 }
 
-ReturnCode ES::CheckStreamKeyPermissions(const u32 uid, const u8* ticket_view,
-                                         const IOS::ES::TMDReader& tmd) const
+ReturnCode ESDevice::CheckStreamKeyPermissions(const u32 uid, const u8* ticket_view,
+                                               const IOS::ES::TMDReader& tmd) const
 {
   const u32 title_flags = tmd.GetTitleFlags();
   // Only allow using this function with some titles (WFS titles).
@@ -739,8 +742,8 @@ ReturnCode ES::CheckStreamKeyPermissions(const u32 uid, const u8* ticket_view,
   return IPC_SUCCESS;
 }
 
-ReturnCode ES::SetUpStreamKey(const u32 uid, const u8* ticket_view, const IOS::ES::TMDReader& tmd,
-                              u32* handle)
+ReturnCode ESDevice::SetUpStreamKey(const u32 uid, const u8* ticket_view,
+                                    const IOS::ES::TMDReader& tmd, u32* handle)
 {
   ReturnCode ret = CheckStreamKeyPermissions(uid, ticket_view, tmd);
   if (ret != IPC_SUCCESS)
@@ -794,7 +797,7 @@ ReturnCode ES::SetUpStreamKey(const u32 uid, const u8* ticket_view, const IOS::E
                                          PID_ES);
 }
 
-IPCCommandResult ES::SetUpStreamKey(const Context& context, const IOCtlVRequest& request)
+IPCCommandResult ESDevice::SetUpStreamKey(const Context& context, const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(2, 1) ||
       request.in_vectors[0].size != sizeof(IOS::ES::TicketView) ||
@@ -818,7 +821,7 @@ IPCCommandResult ES::SetUpStreamKey(const Context& context, const IOCtlVRequest&
   return GetDefaultReply(ret);
 }
 
-IPCCommandResult ES::DeleteStreamKey(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::DeleteStreamKey(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 0) || request.in_vectors[0].size != sizeof(u32))
     return GetDefaultReply(ES_EINVAL);
@@ -827,7 +830,7 @@ IPCCommandResult ES::DeleteStreamKey(const IOCtlVRequest& request)
   return GetDefaultReply(m_ios.GetIOSC().DeleteObject(handle, PID_ES));
 }
 
-bool ES::IsActiveTitlePermittedByTicket(const u8* ticket_view) const
+bool ESDevice::IsActiveTitlePermittedByTicket(const u8* ticket_view) const
 {
   if (!m_title_context.active)
     return false;
@@ -840,7 +843,8 @@ bool ES::IsActiveTitlePermittedByTicket(const u8* ticket_view) const
   return title_identifier && (title_identifier & ~permitted_title_mask) == permitted_title_id;
 }
 
-bool ES::IsIssuerCorrect(VerifyContainerType type, const IOS::ES::CertReader& issuer_cert) const
+bool ESDevice::IsIssuerCorrect(VerifyContainerType type,
+                               const IOS::ES::CertReader& issuer_cert) const
 {
   switch (type)
   {
@@ -857,7 +861,7 @@ bool ES::IsIssuerCorrect(VerifyContainerType type, const IOS::ES::CertReader& is
 
 static const std::string CERT_STORE_PATH = "/sys/cert.sys";
 
-ReturnCode ES::ReadCertStore(std::vector<u8>* buffer) const
+ReturnCode ESDevice::ReadCertStore(std::vector<u8>* buffer) const
 {
   const auto store_file =
       m_ios.GetFS()->OpenFile(PID_KERNEL, PID_KERNEL, CERT_STORE_PATH, FS::Mode::Read);
@@ -870,7 +874,7 @@ ReturnCode ES::ReadCertStore(std::vector<u8>* buffer) const
   return IPC_SUCCESS;
 }
 
-ReturnCode ES::WriteNewCertToStore(const IOS::ES::CertReader& cert)
+ReturnCode ESDevice::WriteNewCertToStore(const IOS::ES::CertReader& cert)
 {
   // Read the current store to determine if the new cert needs to be written.
   std::vector<u8> current_store;
@@ -895,9 +899,9 @@ ReturnCode ES::WriteNewCertToStore(const IOS::ES::CertReader& cert)
   return IPC_SUCCESS;
 }
 
-ReturnCode ES::VerifyContainer(VerifyContainerType type, VerifyMode mode,
-                               const IOS::ES::SignedBlobReader& signed_blob,
-                               const std::vector<u8>& cert_chain, u32* issuer_handle_out)
+ReturnCode ESDevice::VerifyContainer(VerifyContainerType type, VerifyMode mode,
+                                     const IOS::ES::SignedBlobReader& signed_blob,
+                                     const std::vector<u8>& cert_chain, u32* issuer_handle_out)
 {
   if (!signed_blob.IsSignatureValid())
     return ES_EINVAL;
@@ -987,9 +991,9 @@ ReturnCode ES::VerifyContainer(VerifyContainerType type, VerifyMode mode,
   return ret;
 }
 
-ReturnCode ES::VerifyContainer(VerifyContainerType type, VerifyMode mode,
-                               const IOS::ES::CertReader& cert, const std::vector<u8>& cert_chain,
-                               u32 certificate_iosc_handle)
+ReturnCode ESDevice::VerifyContainer(VerifyContainerType type, VerifyMode mode,
+                                     const IOS::ES::CertReader& cert,
+                                     const std::vector<u8>& cert_chain, u32 certificate_iosc_handle)
 {
   IOSC::Handle issuer_handle;
   ReturnCode ret = VerifyContainer(type, mode, cert, cert_chain, &issuer_handle);
@@ -1001,4 +1005,4 @@ ReturnCode ES::VerifyContainer(VerifyContainerType type, VerifyMode mode,
   }
   return ret;
 }
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/ES/ES.h b/Source/Core/Core/IOS/ES/ES.h
@@ -23,7 +23,7 @@ namespace DiscIO
 enum class Platform;
 }
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
 struct TitleContext
 {
@@ -38,10 +38,10 @@ struct TitleContext
   bool first_change = true;
 };
 
-class ES final : public Device
+class ESDevice final : public Device
 {
 public:
-  ES(Kernel& ios, const std::string& device_name);
+  ESDevice(Kernel& ios, const std::string& device_name);
 
   ReturnCode DIVerify(const IOS::ES::TMDReader& tmd, const IOS::ES::TicketReader& ticket);
   bool LaunchTitle(u64 title_id, bool skip_reload = false);
@@ -385,4 +385,4 @@ class ES final : public Device
   ContextArray m_contexts;
   TitleContext m_title_context{};
 };
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/ES/Identity.cpp b/Source/Core/Core/IOS/ES/Identity.cpp
@@ -18,16 +18,16 @@
 #include "Core/IOS/IOSC.h"
 #include "Core/IOS/Uids.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
-ReturnCode ES::GetDeviceId(u32* device_id) const
+ReturnCode ESDevice::GetDeviceId(u32* device_id) const
 {
   *device_id = m_ios.GetIOSC().GetDeviceId();
   INFO_LOG_FMT(IOS_ES, "GetDeviceId: {:08X}", *device_id);
   return IPC_SUCCESS;
 }
 
-IPCCommandResult ES::GetDeviceId(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetDeviceId(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(0, 1) || request.io_vectors[0].size != sizeof(u32))
     return GetDefaultReply(ES_EINVAL);
@@ -40,7 +40,7 @@ IPCCommandResult ES::GetDeviceId(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::Encrypt(u32 uid, const IOCtlVRequest& request)
+IPCCommandResult ESDevice::Encrypt(u32 uid, const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(3, 2))
     return GetDefaultReply(ES_EINVAL);
@@ -57,7 +57,7 @@ IPCCommandResult ES::Encrypt(u32 uid, const IOCtlVRequest& request)
   return GetDefaultReply(ret);
 }
 
-IPCCommandResult ES::Decrypt(u32 uid, const IOCtlVRequest& request)
+IPCCommandResult ESDevice::Decrypt(u32 uid, const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(3, 2))
     return GetDefaultReply(ES_EINVAL);
@@ -74,7 +74,7 @@ IPCCommandResult ES::Decrypt(u32 uid, const IOCtlVRequest& request)
   return GetDefaultReply(ret);
 }
 
-IPCCommandResult ES::CheckKoreaRegion(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::CheckKoreaRegion(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(0, 0))
     return GetDefaultReply(ES_EINVAL);
@@ -87,7 +87,7 @@ IPCCommandResult ES::CheckKoreaRegion(const IOCtlVRequest& request)
   return GetDefaultReply(ES_EINVAL);
 }
 
-IPCCommandResult ES::GetDeviceCertificate(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetDeviceCertificate(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(0, 1) || request.io_vectors[0].size != 0x180)
     return GetDefaultReply(ES_EINVAL);
@@ -99,7 +99,7 @@ IPCCommandResult ES::GetDeviceCertificate(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::Sign(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::Sign(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 2))
     return GetDefaultReply(ES_EINVAL);
@@ -117,8 +117,8 @@ IPCCommandResult ES::Sign(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-ReturnCode ES::VerifySign(const std::vector<u8>& hash, const std::vector<u8>& ecc_signature,
-                          const std::vector<u8>& certs_bytes)
+ReturnCode ESDevice::VerifySign(const std::vector<u8>& hash, const std::vector<u8>& ecc_signature,
+                                const std::vector<u8>& certs_bytes)
 {
   const std::map<std::string, IOS::ES::CertReader> certs = IOS::ES::ParseCertChain(certs_bytes);
   if (certs.empty())
@@ -185,7 +185,7 @@ ReturnCode ES::VerifySign(const std::vector<u8>& hash, const std::vector<u8>& ec
   return IPC_SUCCESS;
 }
 
-IPCCommandResult ES::VerifySign(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::VerifySign(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(3, 0))
     return GetDefaultReply(ES_EINVAL);
@@ -203,4 +203,4 @@ IPCCommandResult ES::VerifySign(const IOCtlVRequest& request)
 
   return GetDefaultReply(VerifySign(hash, ecc_signature, certs));
 }
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/ES/NandUtils.cpp b/Source/Core/Core/IOS/ES/NandUtils.cpp
@@ -22,7 +22,7 @@
 #include "Core/IOS/ES/Formats.h"
 #include "Core/IOS/Uids.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
 static IOS::ES::TMDReader FindTMD(FS::FileSystem* fs, u64 title_id, const std::string& tmd_path)
 {
@@ -37,18 +37,18 @@ static IOS::ES::TMDReader FindTMD(FS::FileSystem* fs, u64 title_id, const std::s
   return IOS::ES::TMDReader{std::move(tmd_bytes)};
 }
 
-IOS::ES::TMDReader ES::FindImportTMD(u64 title_id) const
+IOS::ES::TMDReader ESDevice::FindImportTMD(u64 title_id) const
 {
   return FindTMD(m_ios.GetFS().get(), title_id,
                  Common::GetImportTitlePath(title_id) + "/content/title.tmd");
 }
 
-IOS::ES::TMDReader ES::FindInstalledTMD(u64 title_id) const
+IOS::ES::TMDReader ESDevice::FindInstalledTMD(u64 title_id) const
 {
   return FindTMD(m_ios.GetFS().get(), title_id, Common::GetTMDFileName(title_id));
 }
 
-IOS::ES::TicketReader ES::FindSignedTicket(u64 title_id) const
+IOS::ES::TicketReader ESDevice::FindSignedTicket(u64 title_id) const
 {
   const std::string path = Common::GetTicketFileName(title_id);
   const auto ticket_file = m_ios.GetFS()->OpenFile(PID_KERNEL, PID_KERNEL, path, FS::Mode::Read);
@@ -112,17 +112,17 @@ static std::vector<u64> GetTitlesInTitleOrImport(FS::FileSystem* fs, const std::
   return title_ids;
 }
 
-std::vector<u64> ES::GetInstalledTitles() const
+std::vector<u64> ESDevice::GetInstalledTitles() const
 {
   return GetTitlesInTitleOrImport(m_ios.GetFS().get(), "/title");
 }
 
-std::vector<u64> ES::GetTitleImports() const
+std::vector<u64> ESDevice::GetTitleImports() const
 {
   return GetTitlesInTitleOrImport(m_ios.GetFS().get(), "/import");
 }
 
-std::vector<u64> ES::GetTitlesWithTickets() const
+std::vector<u64> ESDevice::GetTitlesWithTickets() const
 {
   const auto fs = m_ios.GetFS();
   const auto entries = fs->ReadDirectory(PID_KERNEL, PID_KERNEL, "/ticket");
@@ -165,8 +165,8 @@ std::vector<u64> ES::GetTitlesWithTickets() const
 }
 
 std::vector<IOS::ES::Content>
-ES::GetStoredContentsFromTMD(const IOS::ES::TMDReader& tmd,
-                             CheckContentHashes check_content_hashes) const
+ESDevice::GetStoredContentsFromTMD(const IOS::ES::TMDReader& tmd,
+                                   CheckContentHashes check_content_hashes) const
 {
   if (!tmd.IsValid())
     return {};
@@ -205,7 +205,7 @@ ES::GetStoredContentsFromTMD(const IOS::ES::TMDReader& tmd,
   return stored_contents;
 }
 
-u32 ES::GetSharedContentsCount() const
+u32 ESDevice::GetSharedContentsCount() const
 {
   const auto entries = m_ios.GetFS()->ReadDirectory(PID_KERNEL, PID_KERNEL, "/shared1");
   return static_cast<u32>(
@@ -215,7 +215,7 @@ u32 ES::GetSharedContentsCount() const
       }));
 }
 
-std::vector<std::array<u8, 20>> ES::GetSharedContents() const
+std::vector<std::array<u8, 20>> ESDevice::GetSharedContents() const
 {
   const IOS::ES::SharedContentMap map{m_ios.GetFS()};
   return map.GetHashes();
@@ -242,7 +242,7 @@ constexpr FS::Modes title_dir_modes{FS::Mode::ReadWrite, FS::Mode::ReadWrite, FS
 constexpr FS::Modes content_dir_modes{FS::Mode::ReadWrite, FS::Mode::ReadWrite, FS::Mode::None};
 constexpr FS::Modes data_dir_modes{FS::Mode::ReadWrite, FS::Mode::None, FS::Mode::None};
 
-bool ES::CreateTitleDirectories(u64 title_id, u16 group_id) const
+bool ESDevice::CreateTitleDirectories(u64 title_id, u16 group_id) const
 {
   const auto fs = m_ios.GetFS();
 
@@ -278,7 +278,7 @@ bool ES::CreateTitleDirectories(u64 title_id, u16 group_id) const
   return true;
 }
 
-bool ES::InitImport(const IOS::ES::TMDReader& tmd)
+bool ESDevice::InitImport(const IOS::ES::TMDReader& tmd)
 {
   if (!CreateTitleDirectories(tmd.GetTitleId(), tmd.GetGroupId()))
     return false;
@@ -310,7 +310,7 @@ bool ES::InitImport(const IOS::ES::TMDReader& tmd)
   return true;
 }
 
-bool ES::FinishImport(const IOS::ES::TMDReader& tmd)
+bool ESDevice::FinishImport(const IOS::ES::TMDReader& tmd)
 {
   const auto fs = m_ios.GetFS();
   const u64 title_id = tmd.GetTitleId();
@@ -343,7 +343,7 @@ bool ES::FinishImport(const IOS::ES::TMDReader& tmd)
   return true;
 }
 
-bool ES::WriteImportTMD(const IOS::ES::TMDReader& tmd)
+bool ESDevice::WriteImportTMD(const IOS::ES::TMDReader& tmd)
 {
   const auto fs = m_ios.GetFS();
   const std::string tmd_path = "/tmp/title.tmd";
@@ -358,7 +358,7 @@ bool ES::WriteImportTMD(const IOS::ES::TMDReader& tmd)
   return fs->Rename(PID_KERNEL, PID_KERNEL, tmd_path, dest) == FS::ResultCode::Success;
 }
 
-void ES::FinishStaleImport(u64 title_id)
+void ESDevice::FinishStaleImport(u64 title_id)
 {
   const auto fs = m_ios.GetFS();
   const auto import_tmd = FindImportTMD(title_id);
@@ -374,24 +374,24 @@ void ES::FinishStaleImport(u64 title_id)
   }
 }
 
-void ES::FinishAllStaleImports()
+void ESDevice::FinishAllStaleImports()
 {
   const std::vector<u64> titles = GetTitleImports();
   for (const u64& title_id : titles)
     FinishStaleImport(title_id);
 }
 
-std::string ES::GetContentPath(const u64 title_id, const IOS::ES::Content& content,
-                               const IOS::ES::SharedContentMap& content_map) const
+std::string ESDevice::GetContentPath(const u64 title_id, const IOS::ES::Content& content,
+                                     const IOS::ES::SharedContentMap& content_map) const
 {
   if (content.IsShared())
     return content_map.GetFilenameFromSHA1(content.sha1).value_or("");
   return fmt::format("{}/{:08x}.app", Common::GetTitleContentPath(title_id), content.id);
 }
 
-std::string ES::GetContentPath(const u64 title_id, const IOS::ES::Content& content) const
+std::string ESDevice::GetContentPath(const u64 title_id, const IOS::ES::Content& content) const
 {
   IOS::ES::SharedContentMap map{m_ios.GetFS()};
   return GetContentPath(title_id, content, map);
 }
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/ES/TitleContents.cpp b/Source/Core/Core/IOS/ES/TitleContents.cpp
@@ -13,9 +13,9 @@
 #include "Core/IOS/ES/Formats.h"
 #include "Core/IOS/Uids.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
-s32 ES::OpenContent(const IOS::ES::TMDReader& tmd, u16 content_index, u32 uid)
+s32 ESDevice::OpenContent(const IOS::ES::TMDReader& tmd, u16 content_index, u32 uid)
 {
   const u64 title_id = tmd.GetTitleId();
 
@@ -46,7 +46,7 @@ s32 ES::OpenContent(const IOS::ES::TMDReader& tmd, u16 content_index, u32 uid)
   return FS_EFDEXHAUSTED;
 }
 
-IPCCommandResult ES::OpenContent(u32 uid, const IOCtlVRequest& request)
+IPCCommandResult ESDevice::OpenContent(u32 uid, const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(3, 0) || request.in_vectors[0].size != sizeof(u64) ||
       request.in_vectors[1].size != sizeof(IOS::ES::TicketView) ||
@@ -66,7 +66,7 @@ IPCCommandResult ES::OpenContent(u32 uid, const IOCtlVRequest& request)
   return GetDefaultReply(OpenContent(tmd, content_index, uid));
 }
 
-IPCCommandResult ES::OpenActiveTitleContent(u32 caller_uid, const IOCtlVRequest& request)
+IPCCommandResult ESDevice::OpenActiveTitleContent(u32 caller_uid, const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 0) || request.in_vectors[0].size != sizeof(u32))
     return GetDefaultReply(ES_EINVAL);
@@ -84,7 +84,7 @@ IPCCommandResult ES::OpenActiveTitleContent(u32 caller_uid, const IOCtlVRequest&
   return GetDefaultReply(OpenContent(m_title_context.tmd, content_index, caller_uid));
 }
 
-s32 ES::ReadContent(u32 cfd, u8* buffer, u32 size, u32 uid)
+s32 ESDevice::ReadContent(u32 cfd, u8* buffer, u32 size, u32 uid)
 {
   if (cfd >= m_content_table.size())
     return ES_EINVAL;
@@ -99,7 +99,7 @@ s32 ES::ReadContent(u32 cfd, u8* buffer, u32 size, u32 uid)
   return result.Succeeded() ? *result : FS::ConvertResult(result.Error());
 }
 
-IPCCommandResult ES::ReadContent(u32 uid, const IOCtlVRequest& request)
+IPCCommandResult ESDevice::ReadContent(u32 uid, const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 1) || request.in_vectors[0].size != sizeof(u32))
     return GetDefaultReply(ES_EINVAL);
@@ -111,7 +111,7 @@ IPCCommandResult ES::ReadContent(u32 uid, const IOCtlVRequest& request)
   return GetDefaultReply(ReadContent(cfd, Memory::GetPointer(addr), size, uid));
 }
 
-ReturnCode ES::CloseContent(u32 cfd, u32 uid)
+ReturnCode ESDevice::CloseContent(u32 cfd, u32 uid)
 {
   if (cfd >= m_content_table.size())
     return ES_EINVAL;
@@ -128,7 +128,7 @@ ReturnCode ES::CloseContent(u32 cfd, u32 uid)
   return IPC_SUCCESS;
 }
 
-IPCCommandResult ES::CloseContent(u32 uid, const IOCtlVRequest& request)
+IPCCommandResult ESDevice::CloseContent(u32 uid, const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 0) || request.in_vectors[0].size != sizeof(u32))
     return GetDefaultReply(ES_EINVAL);
@@ -137,7 +137,7 @@ IPCCommandResult ES::CloseContent(u32 uid, const IOCtlVRequest& request)
   return GetDefaultReply(CloseContent(cfd, uid));
 }
 
-s32 ES::SeekContent(u32 cfd, u32 offset, SeekMode mode, u32 uid)
+s32 ESDevice::SeekContent(u32 cfd, u32 offset, SeekMode mode, u32 uid)
 {
   if (cfd >= m_content_table.size())
     return ES_EINVAL;
@@ -152,7 +152,7 @@ s32 ES::SeekContent(u32 cfd, u32 offset, SeekMode mode, u32 uid)
   return result.Succeeded() ? *result : FS::ConvertResult(result.Error());
 }
 
-IPCCommandResult ES::SeekContent(u32 uid, const IOCtlVRequest& request)
+IPCCommandResult ESDevice::SeekContent(u32 uid, const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(3, 0))
     return GetDefaultReply(ES_EINVAL);
@@ -163,4 +163,4 @@ IPCCommandResult ES::SeekContent(u32 uid, const IOCtlVRequest& request)
 
   return GetDefaultReply(SeekContent(cfd, offset, mode, uid));
 }
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/ES/TitleInformation.cpp b/Source/Core/Core/IOS/ES/TitleInformation.cpp
@@ -12,12 +12,12 @@
 #include "Core/HW/Memmap.h"
 #include "Core/IOS/ES/Formats.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
 // Used by the GetStoredContents ioctlvs. This assumes that the first output vector
 // is used for the content count (u32).
-IPCCommandResult ES::GetStoredContentsCount(const IOS::ES::TMDReader& tmd,
-                                            const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetStoredContentsCount(const IOS::ES::TMDReader& tmd,
+                                                  const IOCtlVRequest& request)
 {
   if (request.io_vectors[0].size != sizeof(u32) || !tmd.IsValid())
     return GetDefaultReply(ES_EINVAL);
@@ -32,7 +32,8 @@ IPCCommandResult ES::GetStoredContentsCount(const IOS::ES::TMDReader& tmd,
 
 // Used by the GetStoredContents ioctlvs. This assumes that the second input vector is used
 // for the content count and the output vector is used to store a list of content IDs (u32s).
-IPCCommandResult ES::GetStoredContents(const IOS::ES::TMDReader& tmd, const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetStoredContents(const IOS::ES::TMDReader& tmd,
+                                             const IOCtlVRequest& request)
 {
   if (!tmd.IsValid())
     return GetDefaultReply(ES_EINVAL);
@@ -51,7 +52,7 @@ IPCCommandResult ES::GetStoredContents(const IOS::ES::TMDReader& tmd, const IOCt
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::GetStoredContentsCount(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetStoredContentsCount(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 1) || request.in_vectors[0].size != sizeof(u64))
     return GetDefaultReply(ES_EINVAL);
@@ -63,7 +64,7 @@ IPCCommandResult ES::GetStoredContentsCount(const IOCtlVRequest& request)
   return GetStoredContentsCount(tmd, request);
 }
 
-IPCCommandResult ES::GetStoredContents(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetStoredContents(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(2, 1) || request.in_vectors[0].size != sizeof(u64))
     return GetDefaultReply(ES_EINVAL);
@@ -75,7 +76,7 @@ IPCCommandResult ES::GetStoredContents(const IOCtlVRequest& request)
   return GetStoredContents(tmd, request);
 }
 
-IPCCommandResult ES::GetTMDStoredContentsCount(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetTMDStoredContentsCount(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 1))
     return GetDefaultReply(ES_EINVAL);
@@ -85,7 +86,7 @@ IPCCommandResult ES::GetTMDStoredContentsCount(const IOCtlVRequest& request)
   return GetStoredContentsCount(IOS::ES::TMDReader{std::move(tmd_bytes)}, request);
 }
 
-IPCCommandResult ES::GetTMDStoredContents(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetTMDStoredContents(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(2, 1))
     return GetDefaultReply(ES_EINVAL);
@@ -109,7 +110,8 @@ IPCCommandResult ES::GetTMDStoredContents(const IOCtlVRequest& request)
   return GetStoredContents(tmd, request);
 }
 
-IPCCommandResult ES::GetTitleCount(const std::vector<u64>& titles, const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetTitleCount(const std::vector<u64>& titles,
+                                         const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(0, 1) || request.io_vectors[0].size != 4)
     return GetDefaultReply(ES_EINVAL);
@@ -119,7 +121,7 @@ IPCCommandResult ES::GetTitleCount(const std::vector<u64>& titles, const IOCtlVR
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::GetTitles(const std::vector<u64>& titles, const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetTitles(const std::vector<u64>& titles, const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 1))
     return GetDefaultReply(ES_EINVAL);
@@ -133,19 +135,19 @@ IPCCommandResult ES::GetTitles(const std::vector<u64>& titles, const IOCtlVReque
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::GetTitleCount(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetTitleCount(const IOCtlVRequest& request)
 {
   const std::vector<u64> titles = GetInstalledTitles();
   INFO_LOG_FMT(IOS_ES, "GetTitleCount: {} titles", titles.size());
   return GetTitleCount(titles, request);
 }
 
-IPCCommandResult ES::GetTitles(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetTitles(const IOCtlVRequest& request)
 {
   return GetTitles(GetInstalledTitles(), request);
 }
 
-IPCCommandResult ES::GetStoredTMDSize(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetStoredTMDSize(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 1))
     return GetDefaultReply(ES_EINVAL);
@@ -163,7 +165,7 @@ IPCCommandResult ES::GetStoredTMDSize(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::GetStoredTMD(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetStoredTMD(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(2, 1))
     return GetDefaultReply(ES_EINVAL);
@@ -186,19 +188,19 @@ IPCCommandResult ES::GetStoredTMD(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::GetOwnedTitleCount(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetOwnedTitleCount(const IOCtlVRequest& request)
 {
   const std::vector<u64> titles = GetTitlesWithTickets();
   INFO_LOG_FMT(IOS_ES, "GetOwnedTitleCount: {} titles", titles.size());
   return GetTitleCount(titles, request);
 }
 
-IPCCommandResult ES::GetOwnedTitles(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetOwnedTitles(const IOCtlVRequest& request)
 {
   return GetTitles(GetTitlesWithTickets(), request);
 }
 
-IPCCommandResult ES::GetBoot2Version(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetBoot2Version(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(0, 1))
     return GetDefaultReply(ES_EINVAL);
@@ -210,7 +212,7 @@ IPCCommandResult ES::GetBoot2Version(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::GetSharedContentsCount(const IOCtlVRequest& request) const
+IPCCommandResult ESDevice::GetSharedContentsCount(const IOCtlVRequest& request) const
 {
   if (!request.HasNumberOfValidVectors(0, 1) || request.io_vectors[0].size != sizeof(u32))
     return GetDefaultReply(ES_EINVAL);
@@ -222,7 +224,7 @@ IPCCommandResult ES::GetSharedContentsCount(const IOCtlVRequest& request) const
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::GetSharedContents(const IOCtlVRequest& request) const
+IPCCommandResult ESDevice::GetSharedContents(const IOCtlVRequest& request) const
 {
   if (!request.HasNumberOfValidVectors(1, 1) || request.in_vectors[0].size != sizeof(u32))
     return GetDefaultReply(ES_EINVAL);
@@ -238,4 +240,4 @@ IPCCommandResult ES::GetSharedContents(const IOCtlVRequest& request) const
   INFO_LOG_FMT(IOS_ES, "GetSharedContents: {} contents ({} requested)", count, max_count);
   return GetDefaultReply(IPC_SUCCESS);
 }
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/ES/TitleManagement.cpp b/Source/Core/Core/IOS/ES/TitleManagement.cpp
diff --git a/Source/Core/Core/IOS/ES/Views.cpp b/Source/Core/Core/IOS/ES/Views.cpp
@@ -18,7 +18,7 @@
 #include "Core/IOS/ES/Formats.h"
 #include "Core/IOS/VersionInfo.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
 // HACK: Since we do not want to require users to install disc updates when launching
 //       Wii games from the game list (which is the inaccurate game boot path anyway),
@@ -37,7 +37,7 @@ static bool ShouldReturnFakeViewsForIOSes(u64 title_id, const TitleContext& cont
          (ios && SConfig::GetInstance().m_disc_booted_from_game_list && disc_title);
 }
 
-IPCCommandResult ES::GetTicketViewCount(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetTicketViewCount(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 1))
     return GetDefaultReply(ES_EINVAL);
@@ -65,7 +65,7 @@ IPCCommandResult ES::GetTicketViewCount(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::GetTicketViews(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetTicketViews(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(2, 1))
     return GetDefaultReply(ES_EINVAL);
@@ -100,7 +100,7 @@ IPCCommandResult ES::GetTicketViews(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-ReturnCode ES::GetV0TicketFromView(const u8* ticket_view, u8* ticket) const
+ReturnCode ESDevice::GetV0TicketFromView(const u8* ticket_view, u8* ticket) const
 {
   const u64 title_id = Common::swap64(&ticket_view[offsetof(IOS::ES::TicketView, title_id)]);
   const u64 ticket_id = Common::swap64(&ticket_view[offsetof(IOS::ES::TicketView, ticket_id)]);
@@ -137,7 +137,7 @@ ReturnCode ES::GetV0TicketFromView(const u8* ticket_view, u8* ticket) const
   return IPC_SUCCESS;
 }
 
-ReturnCode ES::GetTicketFromView(const u8* ticket_view, u8* ticket, u32* ticket_size) const
+ReturnCode ESDevice::GetTicketFromView(const u8* ticket_view, u8* ticket, u32* ticket_size) const
 {
   const u8 version = ticket_view[offsetof(IOS::ES::TicketView, version)];
   if (version == 1)
@@ -158,7 +158,7 @@ ReturnCode ES::GetTicketFromView(const u8* ticket_view, u8* ticket, u32* ticket_
   return IPC_SUCCESS;
 }
 
-IPCCommandResult ES::GetV0TicketFromView(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetV0TicketFromView(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 1) ||
       request.in_vectors[0].size != sizeof(IOS::ES::TicketView) ||
@@ -170,7 +170,7 @@ IPCCommandResult ES::GetV0TicketFromView(const IOCtlVRequest& request)
                                              Memory::GetPointer(request.io_vectors[0].address)));
 }
 
-IPCCommandResult ES::GetTicketSizeFromView(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetTicketSizeFromView(const IOCtlVRequest& request)
 {
   u32 ticket_size = 0;
   if (!request.HasNumberOfValidVectors(1, 1) ||
@@ -185,7 +185,7 @@ IPCCommandResult ES::GetTicketSizeFromView(const IOCtlVRequest& request)
   return GetDefaultReply(ret);
 }
 
-IPCCommandResult ES::GetTicketFromView(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetTicketFromView(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(2, 1) ||
       request.in_vectors[0].size != sizeof(IOS::ES::TicketView) ||
@@ -203,7 +203,7 @@ IPCCommandResult ES::GetTicketFromView(const IOCtlVRequest& request)
                                            &ticket_size));
 }
 
-IPCCommandResult ES::GetTMDViewSize(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetTMDViewSize(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 1))
     return GetDefaultReply(ES_EINVAL);
@@ -221,7 +221,7 @@ IPCCommandResult ES::GetTMDViewSize(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::GetTMDViews(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::GetTMDViews(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(2, 1) ||
       request.in_vectors[0].size != sizeof(IOS::ES::TMDHeader::title_id) ||
@@ -247,7 +247,7 @@ IPCCommandResult ES::GetTMDViews(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::DIGetTMDViewSize(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::DIGetTMDViewSize(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 1))
     return GetDefaultReply(ES_EINVAL);
@@ -288,7 +288,7 @@ IPCCommandResult ES::DIGetTMDViewSize(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::DIGetTMDView(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::DIGetTMDView(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(2, 1))
     return GetDefaultReply(ES_EINVAL);
@@ -334,7 +334,7 @@ IPCCommandResult ES::DIGetTMDView(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::DIGetTicketView(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::DIGetTicketView(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 1) ||
       request.io_vectors[0].size != sizeof(IOS::ES::TicketView))
@@ -372,7 +372,7 @@ IPCCommandResult ES::DIGetTicketView(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::DIGetTMDSize(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::DIGetTMDSize(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(0, 1) || request.io_vectors[0].size != sizeof(u32))
     return GetDefaultReply(ES_EINVAL);
@@ -385,7 +385,7 @@ IPCCommandResult ES::DIGetTMDSize(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult ES::DIGetTMD(const IOCtlVRequest& request)
+IPCCommandResult ESDevice::DIGetTMD(const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 1) || request.in_vectors[0].size != sizeof(u32))
     return GetDefaultReply(ES_EINVAL);
@@ -405,4 +405,4 @@ IPCCommandResult ES::DIGetTMD(const IOCtlVRequest& request)
   Memory::CopyToEmu(request.io_vectors[0].address, tmd_bytes.data(), tmd_bytes.size());
   return GetDefaultReply(IPC_SUCCESS);
 }
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/FS/FileSystemProxy.cpp b/Source/Core/Core/IOS/FS/FileSystemProxy.cpp
@@ -18,7 +18,7 @@
 #include "Core/IOS/FS/FileSystem.h"
 #include "Core/IOS/Uids.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
 using namespace IOS::HLE::FS;
 
@@ -36,7 +36,7 @@ constexpr u64 CLUSTER_WRITE_TICKS = 300000;
 constexpr u64 CLUSTER_READ_TICKS = 115000;
 constexpr size_t CLUSTER_DATA_SIZE = 0x4000;
 
-FS::FS(Kernel& ios, const std::string& device_name) : Device(ios, device_name)
+FSDevice::FSDevice(Kernel& ios, const std::string& device_name) : Device(ios, device_name)
 {
   if (ios.GetFS()->Delete(PID_KERNEL, PID_KERNEL, "/tmp") == ResultCode::Success)
   {
@@ -45,7 +45,7 @@ FS::FS(Kernel& ios, const std::string& device_name) : Device(ios, device_name)
   }
 }
 
-void FS::DoState(PointerWrap& p)
+void FSDevice::DoState(PointerWrap& p)
 {
   p.Do(m_fd_map);
   p.Do(m_cache_fd);
@@ -103,7 +103,7 @@ static IPCCommandResult GetReplyForSuperblockOperation(ResultCode result)
   return GetFSReply(ConvertResult(result), ticks);
 }
 
-IPCCommandResult FS::Open(const OpenRequest& request)
+IPCCommandResult FSDevice::Open(const OpenRequest& request)
 {
   if (m_fd_map.size() >= 16)
     return GetFSReply(ConvertResult(ResultCode::NoFreeHandle));
@@ -130,7 +130,7 @@ IPCCommandResult FS::Open(const OpenRequest& request)
   return GetFSReply(IPC_SUCCESS, ticks);
 }
 
-IPCCommandResult FS::Close(u32 fd)
+IPCCommandResult FSDevice::Close(u32 fd)
 {
   u64 ticks = 0;
   if (m_fd_map[fd].fs_fd != INVALID_FD)
@@ -157,7 +157,7 @@ IPCCommandResult FS::Close(u32 fd)
   return GetFSReply(IPC_SUCCESS, ticks);
 }
 
-u64 FS::SimulatePopulateFileCache(u32 fd, u32 offset, u32 file_size)
+u64 FSDevice::SimulatePopulateFileCache(u32 fd, u32 offset, u32 file_size)
 {
   if (HasCacheForFile(fd, offset))
     return 0;
@@ -171,7 +171,7 @@ u64 FS::SimulatePopulateFileCache(u32 fd, u32 offset, u32 file_size)
   return ticks;
 }
 
-u64 FS::SimulateFlushFileCache()
+u64 FSDevice::SimulateFlushFileCache()
 {
   if (m_cache_fd == INVALID_FD || !m_dirty_cache)
     return 0;
@@ -181,7 +181,7 @@ u64 FS::SimulateFlushFileCache()
 }
 
 // Simulate parts of the FS read/write logic to estimate ticks for file operations correctly.
-u64 FS::EstimateTicksForReadWrite(const Handle& handle, const ReadWriteRequest& request)
+u64 FSDevice::EstimateTicksForReadWrite(const Handle& handle, const ReadWriteRequest& request)
 {
   u64 ticks = 0;
 
@@ -223,13 +223,13 @@ u64 FS::EstimateTicksForReadWrite(const Handle& handle, const ReadWriteRequest&
   return ticks;
 }
 
-bool FS::HasCacheForFile(u32 fd, u32 offset) const
+bool FSDevice::HasCacheForFile(u32 fd, u32 offset) const
 {
   const u16 chain_index = static_cast<u16>(offset / CLUSTER_DATA_SIZE);
   return m_cache_fd == fd && m_cache_chain_index == chain_index;
 }
 
-IPCCommandResult FS::Read(const ReadWriteRequest& request)
+IPCCommandResult FSDevice::Read(const ReadWriteRequest& request)
 {
   const Handle& handle = m_fd_map[request.fd];
   if (handle.fs_fd == INVALID_FD)
@@ -247,7 +247,7 @@ IPCCommandResult FS::Read(const ReadWriteRequest& request)
   return GetFSReply(*result, ticks);
 }
 
-IPCCommandResult FS::Write(const ReadWriteRequest& request)
+IPCCommandResult FSDevice::Write(const ReadWriteRequest& request)
 {
   const Handle& handle = m_fd_map[request.fd];
   if (handle.fs_fd == INVALID_FD)
@@ -265,7 +265,7 @@ IPCCommandResult FS::Write(const ReadWriteRequest& request)
   return GetFSReply(*result, ticks);
 }
 
-IPCCommandResult FS::Seek(const SeekRequest& request)
+IPCCommandResult FSDevice::Seek(const SeekRequest& request)
 {
   const Handle& handle = m_fd_map[request.fd];
   if (handle.fs_fd == INVALID_FD)
@@ -318,7 +318,7 @@ static Result<T> GetParams(const IOCtlRequest& request)
   return params;
 }
 
-IPCCommandResult FS::IOCtl(const IOCtlRequest& request)
+IPCCommandResult FSDevice::IOCtl(const IOCtlRequest& request)
 {
   const auto it = m_fd_map.find(request.fd);
   if (it == m_fd_map.end())
@@ -353,7 +353,7 @@ IPCCommandResult FS::IOCtl(const IOCtlRequest& request)
   }
 }
 
-IPCCommandResult FS::IOCtlV(const IOCtlVRequest& request)
+IPCCommandResult FSDevice::IOCtlV(const IOCtlVRequest& request)
 {
   const auto it = m_fd_map.find(request.fd);
   if (it == m_fd_map.end())
@@ -370,7 +370,7 @@ IPCCommandResult FS::IOCtlV(const IOCtlVRequest& request)
   }
 }
 
-IPCCommandResult FS::Format(const Handle& handle, const IOCtlRequest& request)
+IPCCommandResult FSDevice::Format(const Handle& handle, const IOCtlRequest& request)
 {
   if (handle.uid != 0)
     return GetFSReply(ConvertResult(ResultCode::AccessDenied));
@@ -379,7 +379,7 @@ IPCCommandResult FS::Format(const Handle& handle, const IOCtlRequest& request)
   return GetReplyForSuperblockOperation(result);
 }
 
-IPCCommandResult FS::GetStats(const Handle& handle, const IOCtlRequest& request)
+IPCCommandResult FSDevice::GetStats(const Handle& handle, const IOCtlRequest& request)
 {
   if (request.buffer_out_size < sizeof(ISFSNandStats))
     return GetFSReply(ConvertResult(ResultCode::Invalid));
@@ -401,7 +401,7 @@ IPCCommandResult FS::GetStats(const Handle& handle, const IOCtlRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult FS::CreateDirectory(const Handle& handle, const IOCtlRequest& request)
+IPCCommandResult FSDevice::CreateDirectory(const Handle& handle, const IOCtlRequest& request)
 {
   const auto params = GetParams<ISFSParams>(request);
   if (!params)
@@ -413,7 +413,7 @@ IPCCommandResult FS::CreateDirectory(const Handle& handle, const IOCtlRequest& r
   return GetReplyForSuperblockOperation(result);
 }
 
-IPCCommandResult FS::ReadDirectory(const Handle& handle, const IOCtlVRequest& request)
+IPCCommandResult FSDevice::ReadDirectory(const Handle& handle, const IOCtlVRequest& request)
 {
   if (request.in_vectors.empty() || request.in_vectors.size() != request.io_vectors.size() ||
       request.in_vectors.size() > 2 || request.in_vectors[0].size != 64)
@@ -467,7 +467,7 @@ IPCCommandResult FS::ReadDirectory(const Handle& handle, const IOCtlVRequest& re
   return GetFSReply(IPC_SUCCESS);
 }
 
-IPCCommandResult FS::SetAttribute(const Handle& handle, const IOCtlRequest& request)
+IPCCommandResult FSDevice::SetAttribute(const Handle& handle, const IOCtlRequest& request)
 {
   const auto params = GetParams<ISFSParams>(request);
   if (!params)
@@ -479,7 +479,7 @@ IPCCommandResult FS::SetAttribute(const Handle& handle, const IOCtlRequest& requ
   return GetReplyForSuperblockOperation(result);
 }
 
-IPCCommandResult FS::GetAttribute(const Handle& handle, const IOCtlRequest& request)
+IPCCommandResult FSDevice::GetAttribute(const Handle& handle, const IOCtlRequest& request)
 {
   if (request.buffer_in_size < 64 || request.buffer_out_size < sizeof(ISFSParams))
     return GetFSReply(ConvertResult(ResultCode::Invalid));
@@ -503,7 +503,7 @@ IPCCommandResult FS::GetAttribute(const Handle& handle, const IOCtlRequest& requ
   return GetFSReply(IPC_SUCCESS, ticks);
 }
 
-IPCCommandResult FS::DeleteFile(const Handle& handle, const IOCtlRequest& request)
+IPCCommandResult FSDevice::DeleteFile(const Handle& handle, const IOCtlRequest& request)
 {
   if (request.buffer_in_size < 64)
     return GetFSReply(ConvertResult(ResultCode::Invalid));
@@ -514,7 +514,7 @@ IPCCommandResult FS::DeleteFile(const Handle& handle, const IOCtlRequest& reques
   return GetReplyForSuperblockOperation(result);
 }
 
-IPCCommandResult FS::RenameFile(const Handle& handle, const IOCtlRequest& request)
+IPCCommandResult FSDevice::RenameFile(const Handle& handle, const IOCtlRequest& request)
 {
   if (request.buffer_in_size < 64 * 2)
     return GetFSReply(ConvertResult(ResultCode::Invalid));
@@ -526,7 +526,7 @@ IPCCommandResult FS::RenameFile(const Handle& handle, const IOCtlRequest& reques
   return GetReplyForSuperblockOperation(result);
 }
 
-IPCCommandResult FS::CreateFile(const Handle& handle, const IOCtlRequest& request)
+IPCCommandResult FSDevice::CreateFile(const Handle& handle, const IOCtlRequest& request)
 {
   const auto params = GetParams<ISFSParams>(request);
   if (!params)
@@ -538,7 +538,7 @@ IPCCommandResult FS::CreateFile(const Handle& handle, const IOCtlRequest& reques
   return GetReplyForSuperblockOperation(result);
 }
 
-IPCCommandResult FS::SetFileVersionControl(const Handle& handle, const IOCtlRequest& request)
+IPCCommandResult FSDevice::SetFileVersionControl(const Handle& handle, const IOCtlRequest& request)
 {
   const auto params = GetParams<ISFSParams>(request);
   if (!params)
@@ -550,7 +550,7 @@ IPCCommandResult FS::SetFileVersionControl(const Handle& handle, const IOCtlRequ
   return GetFSReply(IPC_SUCCESS);
 }
 
-IPCCommandResult FS::GetFileStats(const Handle& handle, const IOCtlRequest& request)
+IPCCommandResult FSDevice::GetFileStats(const Handle& handle, const IOCtlRequest& request)
 {
   if (request.buffer_out_size < 8 || handle.fs_fd == INVALID_FD)
     return GetFSReply(ConvertResult(ResultCode::Invalid));
@@ -567,7 +567,7 @@ IPCCommandResult FS::GetFileStats(const Handle& handle, const IOCtlRequest& requ
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult FS::GetUsage(const Handle& handle, const IOCtlVRequest& request)
+IPCCommandResult FSDevice::GetUsage(const Handle& handle, const IOCtlVRequest& request)
 {
   if (!request.HasNumberOfValidVectors(1, 2) || request.in_vectors[0].size != 64 ||
       request.io_vectors[0].size != 4 || request.io_vectors[1].size != 4)
@@ -586,9 +586,9 @@ IPCCommandResult FS::GetUsage(const Handle& handle, const IOCtlVRequest& request
   return GetFSReply(IPC_SUCCESS);
 }
 
-IPCCommandResult FS::Shutdown(const Handle& handle, const IOCtlRequest& request)
+IPCCommandResult FSDevice::Shutdown(const Handle& handle, const IOCtlRequest& request)
 {
   INFO_LOG_FMT(IOS_FS, "Shutdown");
   return GetFSReply(IPC_SUCCESS);
 }
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/FS/FileSystemProxy.h b/Source/Core/Core/IOS/FS/FileSystemProxy.h
@@ -15,14 +15,14 @@
 
 class PointerWrap;
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
 constexpr IOS::HLE::FS::Fd INVALID_FD = 0xffffffff;
 
-class FS : public Device
+class FSDevice : public Device
 {
 public:
-  FS(Kernel& ios, const std::string& device_name);
+  FSDevice(Kernel& ios, const std::string& device_name);
 
   void DoState(PointerWrap& p) override;
 
@@ -86,4 +86,4 @@ class FS : public Device
   u16 m_cache_chain_index = 0;
   bool m_dirty_cache = false;
 };
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/IOS.cpp b/Source/Core/Core/IOS/IOS.cpp
@@ -285,9 +285,9 @@ std::shared_ptr<FS::FileSystem> Kernel::GetFS()
   return m_fs;
 }
 
-std::shared_ptr<Device::ES> Kernel::GetES()
+std::shared_ptr<ESDevice> Kernel::GetES()
 {
-  return std::static_pointer_cast<Device::ES>(m_device_map.at("/dev/es"));
+  return std::static_pointer_cast<ESDevice>(m_device_map.at("/dev/es"));
 }
 
 // Since we don't have actual processes, we keep track of only the PPC's UID/GID.
@@ -406,9 +406,9 @@ bool Kernel::BootIOS(const u64 ios_title_id, const std::string& boot_content_pat
   return true;
 }
 
-void Kernel::AddDevice(std::unique_ptr<Device::Device> device)
+void Kernel::AddDevice(std::unique_ptr<Device> device)
 {
-  ASSERT(device->GetDeviceType() == Device::Device::DeviceType::Static);
+  ASSERT(device->GetDeviceType() == Device::DeviceType::Static);
   m_device_map.insert_or_assign(device->GetDeviceName(), std::move(device));
 }
 
@@ -418,9 +418,9 @@ void Kernel::AddCoreDevices()
   ASSERT(m_fs);
 
   std::lock_guard lock(m_device_map_mutex);
-  AddDevice(std::make_unique<Device::FS>(*this, "/dev/fs"));
-  AddDevice(std::make_unique<Device::ES>(*this, "/dev/es"));
-  AddDevice(std::make_unique<Device::DolphinDevice>(*this, "/dev/dolphin"));
+  AddDevice(std::make_unique<FSDevice>(*this, "/dev/fs"));
+  AddDevice(std::make_unique<ESDevice>(*this, "/dev/es"));
+  AddDevice(std::make_unique<DolphinDevice>(*this, "/dev/dolphin"));
 }
 
 void Kernel::AddStaticDevices()
@@ -430,65 +430,65 @@ void Kernel::AddStaticDevices()
   const Feature features = GetFeatures(GetVersion());
 
   // OH1 (Bluetooth)
-  AddDevice(std::make_unique<Device::Stub>(*this, "/dev/usb/oh1"));
+  AddDevice(std::make_unique<DeviceStub>(*this, "/dev/usb/oh1"));
   if (!SConfig::GetInstance().m_bt_passthrough_enabled)
-    AddDevice(std::make_unique<Device::BluetoothEmu>(*this, "/dev/usb/oh1/57e/305"));
+    AddDevice(std::make_unique<BluetoothEmuDevice>(*this, "/dev/usb/oh1/57e/305"));
   else
-    AddDevice(std::make_unique<Device::BluetoothReal>(*this, "/dev/usb/oh1/57e/305"));
+    AddDevice(std::make_unique<BluetoothRealDevice>(*this, "/dev/usb/oh1/57e/305"));
 
   // Other core modules
-  AddDevice(std::make_unique<Device::STMImmediate>(*this, "/dev/stm/immediate"));
-  AddDevice(std::make_unique<Device::STMEventHook>(*this, "/dev/stm/eventhook"));
-  AddDevice(std::make_unique<Device::DI>(*this, "/dev/di"));
-  AddDevice(std::make_unique<Device::SDIOSlot0>(*this, "/dev/sdio/slot0"));
-  AddDevice(std::make_unique<Device::Stub>(*this, "/dev/sdio/slot1"));
+  AddDevice(std::make_unique<STMImmediateDevice>(*this, "/dev/stm/immediate"));
+  AddDevice(std::make_unique<STMEventHookDevice>(*this, "/dev/stm/eventhook"));
+  AddDevice(std::make_unique<DIDevice>(*this, "/dev/di"));
+  AddDevice(std::make_unique<SDIOSlot0Device>(*this, "/dev/sdio/slot0"));
+  AddDevice(std::make_unique<DeviceStub>(*this, "/dev/sdio/slot1"));
 
   // Network modules
   if (HasFeature(features, Feature::KD))
   {
-    AddDevice(std::make_unique<Device::NetKDRequest>(*this, "/dev/net/kd/request"));
-    AddDevice(std::make_unique<Device::NetKDTime>(*this, "/dev/net/kd/time"));
+    AddDevice(std::make_unique<NetKDRequestDevice>(*this, "/dev/net/kd/request"));
+    AddDevice(std::make_unique<NetKDTimeDevice>(*this, "/dev/net/kd/time"));
   }
   if (HasFeature(features, Feature::NCD))
   {
-    AddDevice(std::make_unique<Device::NetNCDManage>(*this, "/dev/net/ncd/manage"));
+    AddDevice(std::make_unique<NetNCDManageDevice>(*this, "/dev/net/ncd/manage"));
   }
   if (HasFeature(features, Feature::WiFi))
   {
-    AddDevice(std::make_unique<Device::NetWDCommand>(*this, "/dev/net/wd/command"));
+    AddDevice(std::make_unique<NetWDCommandDevice>(*this, "/dev/net/wd/command"));
   }
   if (HasFeature(features, Feature::SO))
   {
-    AddDevice(std::make_unique<Device::NetIPTop>(*this, "/dev/net/ip/top"));
+    AddDevice(std::make_unique<NetIPTopDevice>(*this, "/dev/net/ip/top"));
   }
   if (HasFeature(features, Feature::SSL))
   {
-    AddDevice(std::make_unique<Device::NetSSL>(*this, "/dev/net/ssl"));
+    AddDevice(std::make_unique<NetSSLDevice>(*this, "/dev/net/ssl"));
   }
 
   // USB modules
   // OH0 is unconditionally added because this device path is registered in all cases.
-  AddDevice(std::make_unique<Device::OH0>(*this, "/dev/usb/oh0"));
+  AddDevice(std::make_unique<OH0>(*this, "/dev/usb/oh0"));
   if (HasFeature(features, Feature::NewUSB))
   {
-    AddDevice(std::make_unique<Device::USB_HIDv5>(*this, "/dev/usb/hid"));
-    AddDevice(std::make_unique<Device::USB_VEN>(*this, "/dev/usb/ven"));
+    AddDevice(std::make_unique<USB_HIDv5>(*this, "/dev/usb/hid"));
+    AddDevice(std::make_unique<USB_VEN>(*this, "/dev/usb/ven"));
 
     // TODO(IOS): register /dev/usb/usb, /dev/usb/msc, /dev/usb/hub and /dev/usb/ehc
     //            as stubs that return IPC_EACCES.
   }
   else
   {
     if (HasFeature(features, Feature::USB_HIDv4))
-      AddDevice(std::make_unique<Device::USB_HIDv4>(*this, "/dev/usb/hid"));
+      AddDevice(std::make_unique<USB_HIDv4>(*this, "/dev/usb/hid"));
     if (HasFeature(features, Feature::USB_KBD))
-      AddDevice(std::make_unique<Device::USB_KBD>(*this, "/dev/usb/kbd"));
+      AddDevice(std::make_unique<USB_KBD>(*this, "/dev/usb/kbd"));
   }
 
   if (HasFeature(features, Feature::WFS))
   {
-    AddDevice(std::make_unique<Device::WFSSRV>(*this, "/dev/usb/wfssrv"));
-    AddDevice(std::make_unique<Device::WFSI>(*this, "/dev/wfsi"));
+    AddDevice(std::make_unique<WFSSRVDevice>(*this, "/dev/usb/wfssrv"));
+    AddDevice(std::make_unique<WFSIDevice>(*this, "/dev/wfsi"));
   }
 }
 
@@ -505,14 +505,14 @@ s32 Kernel::GetFreeDeviceID()
   return -1;
 }
 
-std::shared_ptr<Device::Device> Kernel::GetDeviceByName(std::string_view device_name)
+std::shared_ptr<Device> Kernel::GetDeviceByName(std::string_view device_name)
 {
   std::lock_guard lock(m_device_map_mutex);
   const auto iterator = m_device_map.find(device_name);
   return iterator != m_device_map.end() ? iterator->second : nullptr;
 }
 
-std::shared_ptr<Device::Device> EmulationKernel::GetDeviceByName(std::string_view device_name)
+std::shared_ptr<Device> EmulationKernel::GetDeviceByName(std::string_view device_name)
 {
   return Kernel::GetDeviceByName(device_name);
 }
@@ -529,11 +529,11 @@ IPCCommandResult Kernel::OpenDevice(OpenRequest& request)
   }
   request.fd = new_fd;
 
-  std::shared_ptr<Device::Device> device;
+  std::shared_ptr<Device> device;
   if (request.path.find("/dev/usb/oh0/") == 0 && !GetDeviceByName(request.path) &&
       !HasFeature(GetVersion(), Feature::NewUSB))
   {
-    device = std::make_shared<Device::OH0Device>(*this, request.path);
+    device = std::make_shared<OH0Device>(*this, request.path);
   }
   else if (request.path.find("/dev/") == 0)
   {
@@ -746,7 +746,7 @@ void Kernel::DoState(PointerWrap& p)
   if (m_title_id == Titles::MIOS)
     return;
 
-  // We need to make sure all file handles are closed so IOS::HLE::Device::FS::DoState can
+  // We need to make sure all file handles are closed so IOS::HLE::FSDevice::DoState can
   // successfully save or re-create /tmp
   for (auto& descriptor : m_fdmap)
   {
@@ -765,19 +765,19 @@ void Kernel::DoState(PointerWrap& p)
       p.Do(exists);
       if (exists)
       {
-        auto device_type = Device::Device::DeviceType::Static;
+        auto device_type = Device::DeviceType::Static;
         p.Do(device_type);
         switch (device_type)
         {
-        case Device::Device::DeviceType::Static:
+        case Device::DeviceType::Static:
         {
           std::string device_name;
           p.Do(device_name);
           m_fdmap[i] = GetDeviceByName(device_name);
           break;
         }
-        case Device::Device::DeviceType::OH0:
-          m_fdmap[i] = std::make_shared<Device::OH0Device>(*this, "");
+        case Device::DeviceType::OH0:
+          m_fdmap[i] = std::make_shared<OH0Device>(*this, "");
           m_fdmap[i]->DoState(p);
           break;
         }
@@ -825,13 +825,13 @@ void Init()
       return;
 
     auto sdio_slot0 = s_ios->GetDeviceByName("/dev/sdio/slot0");
-    auto device = static_cast<Device::SDIOSlot0*>(sdio_slot0.get());
+    auto device = static_cast<SDIOSlot0Device*>(sdio_slot0.get());
     if (device)
       device->EventNotify();
   });
 
-  Device::DI::s_finish_executing_di_command =
-      CoreTiming::RegisterEvent("FinishDICommand", Device::DI::FinishDICommandCallback);
+  DIDevice::s_finish_executing_di_command =
+      CoreTiming::RegisterEvent("FinishDICommand", DIDevice::FinishDICommandCallback);
 
   // Start with IOS80 to simulate part of the Wii boot process.
   s_ios = std::make_unique<EmulationKernel>(Titles::SYSTEM_MENU_IOS);

diff --git a/Source/Core/Core/IOS/IOS.h b/Source/Core/Core/IOS/IOS.h
@@ -27,11 +27,8 @@ namespace FS
 class FileSystem;
 }
 
-namespace Device
-{
 class Device;
-class ES;
-}  // namespace Device
+class ESDevice;
 
 struct Request;
 struct OpenRequest;
@@ -82,7 +79,7 @@ class Kernel
   // These are *always* part of the IOS kernel and always available.
   // They are also the only available resource managers even before loading any module.
   std::shared_ptr<FS::FileSystem> GetFS();
-  std::shared_ptr<Device::ES> GetES();
+  std::shared_ptr<ESDevice> GetES();
 
   void SDIO_EventNotify();
 
@@ -108,20 +105,20 @@ class Kernel
   IPCCommandResult HandleIPCCommand(const Request& request);
   void EnqueueIPCAcknowledgement(u32 address, int cycles_in_future = 0);
 
-  void AddDevice(std::unique_ptr<Device::Device> device);
+  void AddDevice(std::unique_ptr<Device> device);
   void AddCoreDevices();
   void AddStaticDevices();
-  std::shared_ptr<Device::Device> GetDeviceByName(std::string_view device_name);
+  std::shared_ptr<Device> GetDeviceByName(std::string_view device_name);
   s32 GetFreeDeviceID();
   IPCCommandResult OpenDevice(OpenRequest& request);
 
   bool m_is_responsible_for_nand_root = false;
   u64 m_title_id = 0;
   static constexpr u8 IPC_MAX_FDS = 0x18;
-  std::map<std::string, std::shared_ptr<Device::Device>, std::less<>> m_device_map;
+  std::map<std::string, std::shared_ptr<Device>, std::less<>> m_device_map;
   std::mutex m_device_map_mutex;
   // TODO: make this fdmap per process.
-  std::array<std::shared_ptr<Device::Device>, IPC_MAX_FDS> m_fdmap;
+  std::array<std::shared_ptr<Device>, IPC_MAX_FDS> m_fdmap;
 
   u32 m_ppc_uid = 0;
   u16 m_ppc_gid = 0;
@@ -145,7 +142,7 @@ class EmulationKernel : public Kernel
 
   // Get a resource manager by name.
   // This only works for devices which are part of the device map.
-  std::shared_ptr<Device::Device> GetDeviceByName(std::string_view device_name);
+  std::shared_ptr<Device> GetDeviceByName(std::string_view device_name);
 };
 
 // Used for controlling and accessing an IOS instance that is tied to emulation.

diff --git a/Source/Core/Core/IOS/Network/IP/Top.cpp b/Source/Core/Core/IOS/Network/IP/Top.cpp
@@ -54,30 +54,31 @@
 #include "jni/AndroidCommon/AndroidCommon.h"
 #endif
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
 enum SOResultCode : s32
 {
   SO_ERROR_INVALID_REQUEST = -51,
   SO_ERROR_HOST_NOT_FOUND = -305,
 };
 
-NetIPTop::NetIPTop(Kernel& ios, const std::string& device_name) : Device(ios, device_name)
+NetIPTopDevice::NetIPTopDevice(Kernel& ios, const std::string& device_name)
+    : Device(ios, device_name)
 {
 #ifdef _WIN32
   const int ret = WSAStartup(MAKEWORD(2, 2), &InitData);
   INFO_LOG_FMT(IOS_NET, "WSAStartup: {}", ret);
 #endif
 }
 
-NetIPTop::~NetIPTop()
+NetIPTopDevice::~NetIPTopDevice()
 {
 #ifdef _WIN32
   WSACleanup();
 #endif
 }
 
-void NetIPTop::DoState(PointerWrap& p)
+void NetIPTopDevice::DoState(PointerWrap& p)
 {
   DoStateShared(p);
   WiiSockMan::GetInstance().DoState(p);
@@ -284,7 +285,7 @@ static DefaultInterface GetSystemDefaultInterfaceOrFallback()
   return GetSystemDefaultInterface().value_or(FALLBACK_VALUES);
 }
 
-IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::IOCtl(const IOCtlRequest& request)
 {
   if (Core::WantsDeterminism())
   {
@@ -341,7 +342,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult NetIPTop::IOCtlV(const IOCtlVRequest& request)
+IPCCommandResult NetIPTopDevice::IOCtlV(const IOCtlVRequest& request)
 {
   switch (request.request)
   {
@@ -363,18 +364,18 @@ IPCCommandResult NetIPTop::IOCtlV(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-void NetIPTop::Update()
+void NetIPTopDevice::Update()
 {
   WiiSockMan::GetInstance().Update();
 }
 
-IPCCommandResult NetIPTop::HandleInitInterfaceRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleInitInterfaceRequest(const IOCtlRequest& request)
 {
   request.Log(GetDeviceName(), Common::Log::IOS_WC24);
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult NetIPTop::HandleSocketRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleSocketRequest(const IOCtlRequest& request)
 {
   const u32 af = Memory::Read_U32(request.buffer_in);
   const u32 type = Memory::Read_U32(request.buffer_in + 4);
@@ -391,7 +392,7 @@ IPCCommandResult NetIPTop::HandleSocketRequest(const IOCtlRequest& request)
   return GetDefaultReply(return_value);
 }
 
-IPCCommandResult NetIPTop::HandleICMPSocketRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleICMPSocketRequest(const IOCtlRequest& request)
 {
   const u32 pf = Memory::Read_U32(request.buffer_in);
 
@@ -401,7 +402,7 @@ IPCCommandResult NetIPTop::HandleICMPSocketRequest(const IOCtlRequest& request)
   return GetDefaultReply(return_value);
 }
 
-IPCCommandResult NetIPTop::HandleCloseRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleCloseRequest(const IOCtlRequest& request)
 {
   const u32 fd = Memory::Read_U32(request.buffer_in);
   WiiSockMan& sm = WiiSockMan::GetInstance();
@@ -414,15 +415,15 @@ IPCCommandResult NetIPTop::HandleCloseRequest(const IOCtlRequest& request)
   return GetDefaultReply(return_value);
 }
 
-IPCCommandResult NetIPTop::HandleDoSockRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleDoSockRequest(const IOCtlRequest& request)
 {
   const u32 fd = Memory::Read_U32(request.buffer_in);
   WiiSockMan& sm = WiiSockMan::GetInstance();
   sm.DoSock(fd, request, static_cast<NET_IOCTL>(request.request));
   return GetNoReply();
 }
 
-IPCCommandResult NetIPTop::HandleShutdownRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleShutdownRequest(const IOCtlRequest& request)
 {
   if (request.buffer_in == 0 || request.buffer_in_size < 8)
   {
@@ -440,7 +441,7 @@ IPCCommandResult NetIPTop::HandleShutdownRequest(const IOCtlRequest& request)
   return GetDefaultReply(return_value);
 }
 
-IPCCommandResult NetIPTop::HandleListenRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleListenRequest(const IOCtlRequest& request)
 {
   u32 fd = Memory::Read_U32(request.buffer_in);
   u32 BACKLOG = Memory::Read_U32(request.buffer_in + 0x04);
@@ -450,7 +451,7 @@ IPCCommandResult NetIPTop::HandleListenRequest(const IOCtlRequest& request)
   return GetDefaultReply(WiiSockMan::GetNetErrorCode(ret, "SO_LISTEN", false));
 }
 
-IPCCommandResult NetIPTop::HandleGetSockOptRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleGetSockOptRequest(const IOCtlRequest& request)
 {
   u32 fd = Memory::Read_U32(request.buffer_out);
   u32 level = Memory::Read_U32(request.buffer_out + 4);
@@ -483,7 +484,7 @@ IPCCommandResult NetIPTop::HandleGetSockOptRequest(const IOCtlRequest& request)
   return GetDefaultReply(return_value);
 }
 
-IPCCommandResult NetIPTop::HandleSetSockOptRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleSetSockOptRequest(const IOCtlRequest& request)
 {
   const u32 fd = Memory::Read_U32(request.buffer_in);
   const u32 level = Memory::Read_U32(request.buffer_in + 4);
@@ -518,7 +519,7 @@ IPCCommandResult NetIPTop::HandleSetSockOptRequest(const IOCtlRequest& request)
   return GetDefaultReply(WiiSockMan::GetNetErrorCode(ret, "SO_SETSOCKOPT", false));
 }
 
-IPCCommandResult NetIPTop::HandleGetSockNameRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleGetSockNameRequest(const IOCtlRequest& request)
 {
   u32 fd = Memory::Read_U32(request.buffer_in);
 
@@ -544,7 +545,7 @@ IPCCommandResult NetIPTop::HandleGetSockNameRequest(const IOCtlRequest& request)
   return GetDefaultReply(ret);
 }
 
-IPCCommandResult NetIPTop::HandleGetPeerNameRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleGetPeerNameRequest(const IOCtlRequest& request)
 {
   u32 fd = Memory::Read_U32(request.buffer_in);
 
@@ -569,7 +570,7 @@ IPCCommandResult NetIPTop::HandleGetPeerNameRequest(const IOCtlRequest& request)
   return GetDefaultReply(ret);
 }
 
-IPCCommandResult NetIPTop::HandleGetHostIDRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleGetHostIDRequest(const IOCtlRequest& request)
 {
   const DefaultInterface interface = GetSystemDefaultInterfaceOrFallback();
   const u32 host_ip = Common::swap32(interface.inet);
@@ -578,7 +579,7 @@ IPCCommandResult NetIPTop::HandleGetHostIDRequest(const IOCtlRequest& request)
   return GetDefaultReply(host_ip);
 }
 
-IPCCommandResult NetIPTop::HandleInetAToNRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleInetAToNRequest(const IOCtlRequest& request)
 {
   const std::string hostname = Memory::GetString(request.buffer_in);
   struct hostent* remoteHost = gethostbyname(hostname.c_str());
@@ -607,14 +608,14 @@ IPCCommandResult NetIPTop::HandleInetAToNRequest(const IOCtlRequest& request)
   return GetDefaultReply(1);
 }
 
-IPCCommandResult NetIPTop::HandleInetPToNRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleInetPToNRequest(const IOCtlRequest& request)
 {
   const std::string address = Memory::GetString(request.buffer_in);
   INFO_LOG_FMT(IOS_NET, "IOCTL_SO_INETPTON (Translating: {})", address);
   return GetDefaultReply(inet_pton(address.c_str(), Memory::GetPointer(request.buffer_out + 4)));
 }
 
-IPCCommandResult NetIPTop::HandleInetNToPRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleInetNToPRequest(const IOCtlRequest& request)
 {
   // u32 af = Memory::Read_U32(BufferIn);
   // u32 validAddress = Memory::Read_U32(request.buffer_in + 4);
@@ -630,7 +631,7 @@ IPCCommandResult NetIPTop::HandleInetNToPRequest(const IOCtlRequest& request)
   return GetDefaultReply(0);
 }
 
-IPCCommandResult NetIPTop::HandlePollRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandlePollRequest(const IOCtlRequest& request)
 {
   WiiSockMan& sm = WiiSockMan::GetInstance();
 
@@ -673,7 +674,7 @@ IPCCommandResult NetIPTop::HandlePollRequest(const IOCtlRequest& request)
   return GetNoReply();
 }
 
-IPCCommandResult NetIPTop::HandleGetHostByNameRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleGetHostByNameRequest(const IOCtlRequest& request)
 {
   if (request.buffer_out_size != 0x460)
   {
@@ -759,13 +760,13 @@ IPCCommandResult NetIPTop::HandleGetHostByNameRequest(const IOCtlRequest& reques
   return GetDefaultReply(0);
 }
 
-IPCCommandResult NetIPTop::HandleICMPCancelRequest(const IOCtlRequest& request)
+IPCCommandResult NetIPTopDevice::HandleICMPCancelRequest(const IOCtlRequest& request)
 {
   ERROR_LOG_FMT(IOS_NET, "IOCTL_SO_ICMPCANCEL");
   return GetDefaultReply(0);
 }
 
-IPCCommandResult NetIPTop::HandleGetInterfaceOptRequest(const IOCtlVRequest& request)
+IPCCommandResult NetIPTopDevice::HandleGetInterfaceOptRequest(const IOCtlVRequest& request)
 {
   const u32 param = Memory::Read_U32(request.in_vectors[0].address);
   const u32 param2 = Memory::Read_U32(request.in_vectors[0].address + 4);
@@ -941,23 +942,23 @@ IPCCommandResult NetIPTop::HandleGetInterfaceOptRequest(const IOCtlVRequest& req
   return GetDefaultReply(0);
 }
 
-IPCCommandResult NetIPTop::HandleSendToRequest(const IOCtlVRequest& request)
+IPCCommandResult NetIPTopDevice::HandleSendToRequest(const IOCtlVRequest& request)
 {
   u32 fd = Memory::Read_U32(request.in_vectors[1].address);
   WiiSockMan& sm = WiiSockMan::GetInstance();
   sm.DoSock(fd, request, IOCTLV_SO_SENDTO);
   return GetNoReply();
 }
 
-IPCCommandResult NetIPTop::HandleRecvFromRequest(const IOCtlVRequest& request)
+IPCCommandResult NetIPTopDevice::HandleRecvFromRequest(const IOCtlVRequest& request)
 {
   u32 fd = Memory::Read_U32(request.in_vectors[0].address);
   WiiSockMan& sm = WiiSockMan::GetInstance();
   sm.DoSock(fd, request, IOCTLV_SO_RECVFROM);
   return GetNoReply();
 }
 
-IPCCommandResult NetIPTop::HandleGetAddressInfoRequest(const IOCtlVRequest& request)
+IPCCommandResult NetIPTopDevice::HandleGetAddressInfoRequest(const IOCtlVRequest& request)
 {
   addrinfo hints;
   const bool hints_valid = request.in_vectors.size() > 2 && request.in_vectors[2].size;
@@ -1046,7 +1047,7 @@ IPCCommandResult NetIPTop::HandleGetAddressInfoRequest(const IOCtlVRequest& requ
   return GetDefaultReply(ret);
 }
 
-IPCCommandResult NetIPTop::HandleICMPPingRequest(const IOCtlVRequest& request)
+IPCCommandResult NetIPTopDevice::HandleICMPPingRequest(const IOCtlVRequest& request)
 {
   struct
   {
@@ -1112,4 +1113,4 @@ IPCCommandResult NetIPTop::HandleICMPPingRequest(const IOCtlVRequest& request)
   // TODO proper error codes
   return GetDefaultReply(0);
 }
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/Network/IP/Top.h b/Source/Core/Core/IOS/Network/IP/Top.h
@@ -61,13 +61,11 @@ enum NET_IOCTL
   IOCTL_SO_ICMPCLOSE
 };
 
-namespace Device
-{
-class NetIPTop : public Device
+class NetIPTopDevice : public Device
 {
 public:
-  NetIPTop(Kernel& ios, const std::string& device_name);
-  virtual ~NetIPTop();
+  NetIPTopDevice(Kernel& ios, const std::string& device_name);
+  virtual ~NetIPTopDevice();
 
   void DoState(PointerWrap& p) override;
   IPCCommandResult IOCtl(const IOCtlRequest& request) override;
@@ -105,5 +103,4 @@ class NetIPTop : public Device
   WSADATA InitData;
 #endif
 };
-}  // namespace Device
 }  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/Network/KD/NetKDRequest.cpp b/Source/Core/Core/IOS/Network/KD/NetKDRequest.cpp
@@ -20,19 +20,19 @@
 #include "Core/IOS/Network/Socket.h"
 #include "Core/IOS/Uids.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
-NetKDRequest::NetKDRequest(Kernel& ios, const std::string& device_name)
+NetKDRequestDevice::NetKDRequestDevice(Kernel& ios, const std::string& device_name)
     : Device(ios, device_name), config{ios.GetFS()}
 {
 }
 
-NetKDRequest::~NetKDRequest()
+NetKDRequestDevice::~NetKDRequestDevice()
 {
   WiiSockMan::GetInstance().Clean();
 }
 
-IPCCommandResult NetKDRequest::IOCtl(const IOCtlRequest& request)
+IPCCommandResult NetKDRequestDevice::IOCtl(const IOCtlRequest& request)
 {
   s32 return_value = 0;
   switch (request.request)
@@ -172,7 +172,7 @@ IPCCommandResult NetKDRequest::IOCtl(const IOCtlRequest& request)
   return GetDefaultReply(return_value);
 }
 
-u8 NetKDRequest::GetAreaCode(const std::string& area) const
+u8 NetKDRequestDevice::GetAreaCode(const std::string& area) const
 {
   static const std::map<std::string, u8> regions = {
       {"JPN", 0}, {"USA", 1}, {"EUR", 2}, {"AUS", 2}, {"BRA", 1}, {"TWN", 3}, {"ROC", 3},
@@ -186,7 +186,7 @@ u8 NetKDRequest::GetAreaCode(const std::string& area) const
   return 7;  // Unknown
 }
 
-u8 NetKDRequest::GetHardwareModel(const std::string& model) const
+u8 NetKDRequestDevice::GetHardwareModel(const std::string& model) const
 {
   static const std::map<std::string, u8> models = {
       {"RVL", MODEL_RVL},
@@ -214,8 +214,8 @@ static u64 u64_insert_byte(u64 value, u8 shift, u8 byte)
   return (value & ~mask) | inst;
 }
 
-s32 NetKDRequest::NWC24MakeUserID(u64* nwc24_id, u32 hollywood_id, u16 id_ctr, u8 hardware_model,
-                                  u8 area_code)
+s32 NetKDRequestDevice::NWC24MakeUserID(u64* nwc24_id, u32 hollywood_id, u16 id_ctr,
+                                        u8 hardware_model, u8 area_code)
 {
   const u8 table2[8] = {0x1, 0x5, 0x0, 0x4, 0x2, 0x3, 0x6, 0x7};
   const u8 table1[16] = {0x4, 0xB, 0x7, 0x9, 0xF, 0x1, 0xD, 0x3,
@@ -266,4 +266,4 @@ s32 NetKDRequest::NWC24MakeUserID(u64* nwc24_id, u32 hollywood_id, u16 id_ctr, u
 
   return NWC24::WC24_OK;
 }
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/Network/KD/NetKDRequest.h b/Source/Core/Core/IOS/Network/KD/NetKDRequest.h
@@ -10,16 +10,16 @@
 #include "Core/IOS/Device.h"
 #include "Core/IOS/Network/KD/NWC24Config.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
 // KD is the IOS module responsible for implementing WiiConnect24 functionality.
 // It can perform HTTPS downloads, send and receive mail via SMTP, and execute a
 // JavaScript-like language while the Wii is in standby mode.
-class NetKDRequest : public Device
+class NetKDRequestDevice : public Device
 {
 public:
-  NetKDRequest(Kernel& ios, const std::string& device_name);
-  ~NetKDRequest() override;
+  NetKDRequestDevice(Kernel& ios, const std::string& device_name);
+  ~NetKDRequestDevice() override;
 
   IPCCommandResult IOCtl(const IOCtlRequest& request) override;
 
@@ -66,4 +66,4 @@ class NetKDRequest : public Device
 
   NWC24::NWC24Config config;
 };
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/Network/KD/NetKDTime.cpp b/Source/Core/Core/IOS/Network/KD/NetKDTime.cpp
@@ -10,15 +10,16 @@
 #include "Core/HW/EXI/EXI_DeviceIPL.h"
 #include "Core/HW/Memmap.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
-NetKDTime::NetKDTime(Kernel& ios, const std::string& device_name) : Device(ios, device_name)
+NetKDTimeDevice::NetKDTimeDevice(Kernel& ios, const std::string& device_name)
+    : Device(ios, device_name)
 {
 }
 
-NetKDTime::~NetKDTime() = default;
+NetKDTimeDevice::~NetKDTimeDevice() = default;
 
-IPCCommandResult NetKDTime::IOCtl(const IOCtlRequest& request)
+IPCCommandResult NetKDTimeDevice::IOCtl(const IOCtlRequest& request)
 {
   s32 result = 0;
   u32 common_result = 0;
@@ -74,15 +75,15 @@ IPCCommandResult NetKDTime::IOCtl(const IOCtlRequest& request)
   return GetDefaultReply(result);
 }
 
-u64 NetKDTime::GetAdjustedUTC() const
+u64 NetKDTimeDevice::GetAdjustedUTC() const
 {
   return ExpansionInterface::CEXIIPL::GetEmulatedTime(ExpansionInterface::CEXIIPL::UNIX_EPOCH) +
          utcdiff;
 }
 
-void NetKDTime::SetAdjustedUTC(u64 wii_utc)
+void NetKDTimeDevice::SetAdjustedUTC(u64 wii_utc)
 {
   utcdiff = ExpansionInterface::CEXIIPL::GetEmulatedTime(ExpansionInterface::CEXIIPL::UNIX_EPOCH) -
             wii_utc;
 }
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/Network/KD/NetKDTime.h b/Source/Core/Core/IOS/Network/KD/NetKDTime.h
@@ -9,13 +9,13 @@
 #include "Common/CommonTypes.h"
 #include "Core/IOS/Device.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
-class NetKDTime : public Device
+class NetKDTimeDevice : public Device
 {
 public:
-  NetKDTime(Kernel& ios, const std::string& device_name);
-  ~NetKDTime() override;
+  NetKDTimeDevice(Kernel& ios, const std::string& device_name);
+  ~NetKDTimeDevice() override;
 
   IPCCommandResult IOCtl(const IOCtlRequest& request) override;
 
@@ -44,4 +44,4 @@ class NetKDTime : public Device
   u64 rtc = 0;
   s64 utcdiff = 0;
 };
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/Network/NCD/Manage.cpp b/Source/Core/Core/IOS/Network/NCD/Manage.cpp
@@ -13,20 +13,21 @@
 #include "Core/HW/Memmap.h"
 #include "Core/IOS/Network/MACUtils.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
-NetNCDManage::NetNCDManage(Kernel& ios, const std::string& device_name) : Device(ios, device_name)
+NetNCDManageDevice::NetNCDManageDevice(Kernel& ios, const std::string& device_name)
+    : Device(ios, device_name)
 {
   config.ReadConfig(ios.GetFS().get());
 }
 
-void NetNCDManage::DoState(PointerWrap& p)
+void NetNCDManageDevice::DoState(PointerWrap& p)
 {
   Device::DoState(p);
   p.Do(m_ipc_fd);
 }
 
-IPCCommandResult NetNCDManage::IOCtlV(const IOCtlVRequest& request)
+IPCCommandResult NetNCDManageDevice::IOCtlV(const IOCtlVRequest& request)
 {
   s32 return_value = IPC_SUCCESS;
   u32 common_result = 0;
@@ -131,4 +132,4 @@ IPCCommandResult NetNCDManage::IOCtlV(const IOCtlVRequest& request)
   }
   return GetDefaultReply(return_value);
 }
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/Network/NCD/Manage.h b/Source/Core/Core/IOS/Network/NCD/Manage.h
@@ -10,13 +10,13 @@
 #include "Core/IOS/Device.h"
 #include "Core/IOS/Network/NCD/WiiNetConfig.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
 // Interface for reading and changing network configuration (probably some other stuff as well)
-class NetNCDManage : public Device
+class NetNCDManageDevice : public Device
 {
 public:
-  NetNCDManage(Kernel& ios, const std::string& device_name);
+  NetNCDManageDevice(Kernel& ios, const std::string& device_name);
 
   IPCCommandResult IOCtlV(const IOCtlVRequest& request) override;
 
@@ -38,4 +38,4 @@ class NetNCDManage : public Device
   Net::WiiNetConfig config;
   u32 m_ipc_fd = 0;
 };
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/Network/SSL.cpp b/Source/Core/Core/IOS/Network/SSL.cpp
@@ -21,9 +21,9 @@
 #include "Core/HW/Memmap.h"
 #include "Core/IOS/Network/Socket.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
-WII_SSL NetSSL::_SSL[IOS::HLE::NET_SSL_MAXINSTANCES];
+WII_SSL NetSSLDevice::_SSL[IOS::HLE::NET_SSL_MAXINSTANCES];
 
 static constexpr mbedtls_x509_crt_profile mbedtls_x509_crt_profile_wii = {
     /* Hashes from SHA-1 and above */
@@ -68,15 +68,15 @@ int SSLRecv(void* ctx, unsigned char* buf, size_t len)
 }
 }  // namespace
 
-NetSSL::NetSSL(Kernel& ios, const std::string& device_name) : Device(ios, device_name)
+NetSSLDevice::NetSSLDevice(Kernel& ios, const std::string& device_name) : Device(ios, device_name)
 {
   for (WII_SSL& ssl : _SSL)
   {
     ssl.active = false;
   }
 }
 
-NetSSL::~NetSSL()
+NetSSLDevice::~NetSSLDevice()
 {
   // Cleanup sessions
   for (WII_SSL& ssl : _SSL)
@@ -101,7 +101,7 @@ NetSSL::~NetSSL()
   }
 }
 
-int NetSSL::GetSSLFreeID() const
+int NetSSLDevice::GetSSLFreeID() const
 {
   for (int i = 0; i < NET_SSL_MAXINSTANCES; i++)
   {
@@ -113,7 +113,7 @@ int NetSSL::GetSSLFreeID() const
   return 0;
 }
 
-IPCCommandResult NetSSL::IOCtl(const IOCtlRequest& request)
+IPCCommandResult NetSSLDevice::IOCtl(const IOCtlRequest& request)
 {
   request.Log(GetDeviceName(), Common::Log::IOS_SSL, Common::Log::LINFO);
   return GetDefaultReply(IPC_SUCCESS);
@@ -167,7 +167,7 @@ static std::vector<u8> ReadCertFile(const std::string& path, const std::array<u8
   return bytes;
 }
 
-IPCCommandResult NetSSL::IOCtlV(const IOCtlVRequest& request)
+IPCCommandResult NetSSLDevice::IOCtlV(const IOCtlVRequest& request)
 {
   u32 BufferIn = 0, BufferIn2 = 0, BufferIn3 = 0;
   u32 BufferInSize = 0, BufferInSize2 = 0, BufferInSize3 = 0;
@@ -602,4 +602,4 @@ IPCCommandResult NetSSL::IOCtlV(const IOCtlVRequest& request)
   // SSL return codes are written to BufferIn
   return GetDefaultReply(IPC_SUCCESS);
 }
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/Network/SSL.h b/Source/Core/Core/IOS/Network/SSL.h
@@ -80,14 +80,12 @@ struct WII_SSL
   bool active;
 };
 
-namespace Device
-{
-class NetSSL : public Device
+class NetSSLDevice : public Device
 {
 public:
-  NetSSL(Kernel& ios, const std::string& device_name);
+  NetSSLDevice(Kernel& ios, const std::string& device_name);
 
-  virtual ~NetSSL();
+  virtual ~NetSSLDevice();
 
   IPCCommandResult IOCtl(const IOCtlRequest& request) override;
   IPCCommandResult IOCtlV(const IOCtlVRequest& request) override;
@@ -102,7 +100,6 @@ class NetSSL : public Device
 
 constexpr bool IsSSLIDValid(int id)
 {
-  return (id >= 0 && id < NET_SSL_MAXINSTANCES && IOS::HLE::Device::NetSSL::_SSL[id].active);
+  return (id >= 0 && id < NET_SSL_MAXINSTANCES && IOS::HLE::NetSSLDevice::_SSL[id].active);
 }
-}  // namespace Device
 }  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/Network/Socket.cpp b/Source/Core/Core/IOS/Network/Socket.cpp
@@ -374,13 +374,13 @@ void WiiSocket::Update(bool read, bool write, bool except)
       if (it->is_ssl)
       {
         int sslID = Memory::Read_U32(BufferOut) - 1;
-        if (IOS::HLE::Device::IsSSLIDValid(sslID))
+        if (IOS::HLE::IsSSLIDValid(sslID))
         {
           switch (it->ssl_type)
           {
           case IOCTLV_NET_SSL_DOHANDSHAKE:
           {
-            mbedtls_ssl_context* ctx = &Device::NetSSL::_SSL[sslID].ctx;
+            mbedtls_ssl_context* ctx = &NetSSLDevice::_SSL[sslID].ctx;
             const int ret = mbedtls_ssl_handshake(ctx);
             if (ret != 0)
             {
@@ -457,7 +457,7 @@ void WiiSocket::Update(bool read, bool write, bool except)
           }
           case IOCTLV_NET_SSL_WRITE:
           {
-            WII_SSL* ssl = &Device::NetSSL::_SSL[sslID];
+            WII_SSL* ssl = &NetSSLDevice::_SSL[sslID];
             const int ret =
                 mbedtls_ssl_write(&ssl->ctx, Memory::GetPointer(BufferOut2), BufferOutSize2);
 
@@ -491,7 +491,7 @@ void WiiSocket::Update(bool read, bool write, bool except)
           }
           case IOCTLV_NET_SSL_READ:
           {
-            WII_SSL* ssl = &Device::NetSSL::_SSL[sslID];
+            WII_SSL* ssl = &NetSSLDevice::_SSL[sslID];
             const int ret =
                 mbedtls_ssl_read(&ssl->ctx, Memory::GetPointer(BufferIn2), BufferInSize2);
 

diff --git a/Source/Core/Core/IOS/Network/WD/Command.cpp b/Source/Core/Core/IOS/Network/WD/Command.cpp
@@ -16,7 +16,7 @@
 #include "Core/HW/Memmap.h"
 #include "Core/IOS/Network/MACUtils.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
 namespace
 {
@@ -48,7 +48,7 @@ u16 MakeNitroAllowedChannelMask(u16 enabled_channels_mask, u16 nitro_mask)
 }
 }  // namespace
 
-NetWDCommand::Status NetWDCommand::GetTargetStatusForMode(WD::Mode mode)
+NetWDCommandDevice::Status NetWDCommandDevice::GetTargetStatusForMode(WD::Mode mode)
 {
   switch (mode)
   {
@@ -61,7 +61,8 @@ NetWDCommand::Status NetWDCommand::GetTargetStatusForMode(WD::Mode mode)
   }
 }
 
-NetWDCommand::NetWDCommand(Kernel& ios, const std::string& device_name) : Device(ios, device_name)
+NetWDCommandDevice::NetWDCommandDevice(Kernel& ios, const std::string& device_name)
+    : Device(ios, device_name)
 {
   // TODO: use the MPCH setting in setting.txt to determine this value.
   m_nitro_enabled_channels = LegalNitroChannelMask;
@@ -77,14 +78,14 @@ NetWDCommand::NetWDCommand(Kernel& ios, const std::string& device_name) : Device
   m_info.initialised = true;
 }
 
-void NetWDCommand::Update()
+void NetWDCommandDevice::Update()
 {
   Device::Update();
   ProcessRecvRequests();
   HandleStateChange();
 }
 
-void NetWDCommand::ProcessRecvRequests()
+void NetWDCommandDevice::ProcessRecvRequests()
 {
   // Because we currently do not actually emulate the wireless driver, we have no frames
   // and no notification data that could be used to reply to requests.
@@ -125,7 +126,7 @@ void NetWDCommand::ProcessRecvRequests()
   process_queue(m_recv_frame_requests);
 }
 
-void NetWDCommand::HandleStateChange()
+void NetWDCommandDevice::HandleStateChange()
 {
   const auto status = m_status;
   const auto target_status = m_target_status;
@@ -168,7 +169,7 @@ void NetWDCommand::HandleStateChange()
                target_status);
 }
 
-void NetWDCommand::DoState(PointerWrap& p)
+void NetWDCommandDevice::DoState(PointerWrap& p)
 {
   Device::DoState(p);
   p.Do(m_ipc_owner_fd);
@@ -182,7 +183,7 @@ void NetWDCommand::DoState(PointerWrap& p)
   p.Do(m_recv_notification_requests);
 }
 
-IPCCommandResult NetWDCommand::Open(const OpenRequest& request)
+IPCCommandResult NetWDCommandDevice::Open(const OpenRequest& request)
 {
   if (m_ipc_owner_fd < 0)
   {
@@ -211,7 +212,7 @@ IPCCommandResult NetWDCommand::Open(const OpenRequest& request)
   return Device::Open(request);
 }
 
-IPCCommandResult NetWDCommand::Close(u32 fd)
+IPCCommandResult NetWDCommandDevice::Close(u32 fd)
 {
   if (m_ipc_owner_fd < 0 || fd != u32(m_ipc_owner_fd))
   {
@@ -227,7 +228,7 @@ IPCCommandResult NetWDCommand::Close(u32 fd)
   return Device::Close(fd);
 }
 
-IPCCommandResult NetWDCommand::SetLinkState(const IOCtlVRequest& request)
+IPCCommandResult NetWDCommandDevice::SetLinkState(const IOCtlVRequest& request)
 {
   const auto* vector = request.GetVector(0);
   if (!vector || vector->address == 0)
@@ -263,7 +264,7 @@ IPCCommandResult NetWDCommand::SetLinkState(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult NetWDCommand::GetLinkState(const IOCtlVRequest& request) const
+IPCCommandResult NetWDCommandDevice::GetLinkState(const IOCtlVRequest& request) const
 {
   INFO_LOG_FMT(IOS_NET, "WD_GetLinkState called (status={}, mode={})", m_status, m_mode);
   if (!WD::IsValidMode(m_mode))
@@ -273,7 +274,7 @@ IPCCommandResult NetWDCommand::GetLinkState(const IOCtlVRequest& request) const
   return GetDefaultReply(u32(m_status == GetTargetStatusForMode(m_mode)));
 }
 
-IPCCommandResult NetWDCommand::Disassociate(const IOCtlVRequest& request)
+IPCCommandResult NetWDCommandDevice::Disassociate(const IOCtlVRequest& request)
 {
   const auto* vector = request.GetVector(0);
   if (!vector || vector->address == 0)
@@ -303,7 +304,7 @@ IPCCommandResult NetWDCommand::Disassociate(const IOCtlVRequest& request)
   return GetDefaultReply(u32(ResultCode::IllegalParameter));
 }
 
-IPCCommandResult NetWDCommand::GetInfo(const IOCtlVRequest& request) const
+IPCCommandResult NetWDCommandDevice::GetInfo(const IOCtlVRequest& request) const
 {
   const auto* vector = request.GetVector(0);
   if (!vector || vector->address == 0)
@@ -313,7 +314,7 @@ IPCCommandResult NetWDCommand::GetInfo(const IOCtlVRequest& request) const
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult NetWDCommand::IOCtlV(const IOCtlVRequest& request)
+IPCCommandResult NetWDCommandDevice::IOCtlV(const IOCtlVRequest& request)
 {
   switch (request.request)
   {
@@ -383,4 +384,4 @@ IPCCommandResult NetWDCommand::IOCtlV(const IOCtlVRequest& request)
 
   return GetDefaultReply(IPC_SUCCESS);
 }
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/Network/WD/Command.h b/Source/Core/Core/IOS/Network/WD/Command.h
@@ -37,9 +37,9 @@ constexpr bool IsValidMode(Mode mode)
 }
 }  // namespace IOS::HLE::WD
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
-class NetWDCommand : public Device
+class NetWDCommandDevice : public Device
 {
 public:
   enum class ResultCode : u32
@@ -50,7 +50,7 @@ class NetWDCommand : public Device
     DriverError = 0x80008003,
   };
 
-  NetWDCommand(Kernel& ios, const std::string& device_name);
+  NetWDCommandDevice(Kernel& ios, const std::string& device_name);
 
   IPCCommandResult Open(const OpenRequest& request) override;
   IPCCommandResult Close(u32 fd) override;
@@ -172,4 +172,4 @@ class NetWDCommand : public Device
   std::deque<u32> m_recv_frame_requests;
   std::deque<u32> m_recv_notification_requests;
 };
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/SDIO/SDIOSlot0.cpp b/Source/Core/Core/IOS/SDIO/SDIOSlot0.cpp
@@ -21,16 +21,16 @@
 #include "Core/IOS/IOS.h"
 #include "Core/IOS/VersionInfo.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
-SDIOSlot0::SDIOSlot0(Kernel& ios, const std::string& device_name)
+SDIOSlot0Device::SDIOSlot0Device(Kernel& ios, const std::string& device_name)
     : Device(ios, device_name), m_sdhc_supported(HasFeature(ios.GetVersion(), Feature::SDv2))
 {
   if (!Config::Get(Config::MAIN_ALLOW_SD_WRITES))
     INFO_LOG_FMT(IOS_SD, "Writes to SD card disabled by user");
 }
 
-void SDIOSlot0::DoState(PointerWrap& p)
+void SDIOSlot0Device::DoState(PointerWrap& p)
 {
   DoStateShared(p);
   if (p.GetMode() == PointerWrap::MODE_READ)
@@ -45,7 +45,7 @@ void SDIOSlot0::DoState(PointerWrap& p)
   p.Do(m_sdhc_supported);
 }
 
-void SDIOSlot0::EventNotify()
+void SDIOSlot0Device::EventNotify()
 {
   if (!m_event)
     return;
@@ -59,7 +59,7 @@ void SDIOSlot0::EventNotify()
   }
 }
 
-void SDIOSlot0::OpenInternal()
+void SDIOSlot0Device::OpenInternal()
 {
   const std::string filename = File::GetUserPath(F_WIISDCARD_IDX);
   m_card.Open(filename, "r+b");
@@ -79,7 +79,7 @@ void SDIOSlot0::OpenInternal()
   }
 }
 
-IPCCommandResult SDIOSlot0::Open(const OpenRequest& request)
+IPCCommandResult SDIOSlot0Device::Open(const OpenRequest& request)
 {
   OpenInternal();
   m_registers.fill(0);
@@ -89,7 +89,7 @@ IPCCommandResult SDIOSlot0::Open(const OpenRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult SDIOSlot0::Close(u32 fd)
+IPCCommandResult SDIOSlot0Device::Close(u32 fd)
 {
   m_card.Close();
   m_block_length = 0;
@@ -98,7 +98,7 @@ IPCCommandResult SDIOSlot0::Close(u32 fd)
   return Device::Close(fd);
 }
 
-IPCCommandResult SDIOSlot0::IOCtl(const IOCtlRequest& request)
+IPCCommandResult SDIOSlot0Device::IOCtl(const IOCtlRequest& request)
 {
   Memory::Memset(request.buffer_out, 0, request.buffer_out_size);
 
@@ -126,7 +126,7 @@ IPCCommandResult SDIOSlot0::IOCtl(const IOCtlRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult SDIOSlot0::IOCtlV(const IOCtlVRequest& request)
+IPCCommandResult SDIOSlot0Device::IOCtlV(const IOCtlVRequest& request)
 {
   switch (request.request)
   {
@@ -140,9 +140,9 @@ IPCCommandResult SDIOSlot0::IOCtlV(const IOCtlVRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-s32 SDIOSlot0::ExecuteCommand(const Request& request, u32 buffer_in, u32 buffer_in_size,
-                              u32 rw_buffer, u32 rw_buffer_size, u32 buffer_out,
-                              u32 buffer_out_size)
+s32 SDIOSlot0Device::ExecuteCommand(const Request& request, u32 buffer_in, u32 buffer_in_size,
+                                    u32 rw_buffer, u32 rw_buffer_size, u32 buffer_out,
+                                    u32 buffer_out_size)
 {
   // The game will send us a SendCMD with this information. To be able to read and write
   // to a file we need to prepare a 0x10 byte output buffer as response.
@@ -325,7 +325,7 @@ s32 SDIOSlot0::ExecuteCommand(const Request& request, u32 buffer_in, u32 buffer_
   return ret;
 }
 
-IPCCommandResult SDIOSlot0::WriteHCRegister(const IOCtlRequest& request)
+IPCCommandResult SDIOSlot0Device::WriteHCRegister(const IOCtlRequest& request)
 {
   const u32 reg = Memory::Read_U32(request.buffer_in);
   const u32 val = Memory::Read_U32(request.buffer_in + 16);
@@ -357,7 +357,7 @@ IPCCommandResult SDIOSlot0::WriteHCRegister(const IOCtlRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult SDIOSlot0::ReadHCRegister(const IOCtlRequest& request)
+IPCCommandResult SDIOSlot0Device::ReadHCRegister(const IOCtlRequest& request)
 {
   const u32 reg = Memory::Read_U32(request.buffer_in);
 
@@ -375,7 +375,7 @@ IPCCommandResult SDIOSlot0::ReadHCRegister(const IOCtlRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult SDIOSlot0::ResetCard(const IOCtlRequest& request)
+IPCCommandResult SDIOSlot0Device::ResetCard(const IOCtlRequest& request)
 {
   INFO_LOG_FMT(IOS_SD, "IOCTL_RESETCARD");
 
@@ -385,7 +385,7 @@ IPCCommandResult SDIOSlot0::ResetCard(const IOCtlRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult SDIOSlot0::SetClk(const IOCtlRequest& request)
+IPCCommandResult SDIOSlot0Device::SetClk(const IOCtlRequest& request)
 {
   INFO_LOG_FMT(IOS_SD, "IOCTL_SETCLK");
 
@@ -398,7 +398,7 @@ IPCCommandResult SDIOSlot0::SetClk(const IOCtlRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult SDIOSlot0::SendCommand(const IOCtlRequest& request)
+IPCCommandResult SDIOSlot0Device::SendCommand(const IOCtlRequest& request)
 {
   INFO_LOG_FMT(IOS_SD, "IOCTL_SENDCMD {:x} IPC:{:08x}", Memory::Read_U32(request.buffer_in),
                request.address);
@@ -416,7 +416,7 @@ IPCCommandResult SDIOSlot0::SendCommand(const IOCtlRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult SDIOSlot0::GetStatus(const IOCtlRequest& request)
+IPCCommandResult SDIOSlot0Device::GetStatus(const IOCtlRequest& request)
 {
   // Since IOS does the SD initialization itself, we just say we're always initialized.
   if (m_card)
@@ -453,7 +453,7 @@ IPCCommandResult SDIOSlot0::GetStatus(const IOCtlRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult SDIOSlot0::GetOCRegister(const IOCtlRequest& request)
+IPCCommandResult SDIOSlot0Device::GetOCRegister(const IOCtlRequest& request)
 {
   const u32 ocr = GetOCRegister();
   INFO_LOG_FMT(IOS_SD, "IOCTL_GETOCR. Replying with ocr {:x}", ocr);
@@ -462,7 +462,7 @@ IPCCommandResult SDIOSlot0::GetOCRegister(const IOCtlRequest& request)
   return GetDefaultReply(IPC_SUCCESS);
 }
 
-IPCCommandResult SDIOSlot0::SendCommand(const IOCtlVRequest& request)
+IPCCommandResult SDIOSlot0Device::SendCommand(const IOCtlVRequest& request)
 {
   DEBUG_LOG_FMT(IOS_SD, "IOCTLV_SENDCMD {:#010x}", Memory::Read_U32(request.in_vectors[0].address));
   Memory::Memset(request.io_vectors[0].address, 0, request.io_vectors[0].size);
@@ -475,7 +475,7 @@ IPCCommandResult SDIOSlot0::SendCommand(const IOCtlVRequest& request)
   return GetDefaultReply(return_value);
 }
 
-u32 SDIOSlot0::GetOCRegister() const
+u32 SDIOSlot0Device::GetOCRegister() const
 {
   u32 ocr = 0x00ff8000;
   if (m_status & CARD_INITIALIZED)
@@ -485,7 +485,7 @@ u32 SDIOSlot0::GetOCRegister() const
   return ocr;
 }
 
-std::array<u32, 4> SDIOSlot0::GetCSDv1() const
+std::array<u32, 4> SDIOSlot0Device::GetCSDv1() const
 {
   u64 size = m_card.GetSize();
 
@@ -569,7 +569,7 @@ std::array<u32, 4> SDIOSlot0::GetCSDv1() const
   }};
 }
 
-std::array<u32, 4> SDIOSlot0::GetCSDv2() const
+std::array<u32, 4> SDIOSlot0Device::GetCSDv2() const
 {
   const u64 size = m_card.GetSize();
 
@@ -626,18 +626,18 @@ std::array<u32, 4> SDIOSlot0::GetCSDv2() const
   }};
 }
 
-u64 SDIOSlot0::GetAddressFromRequest(u32 arg) const
+u64 SDIOSlot0Device::GetAddressFromRequest(u32 arg) const
 {
   u64 address(arg);
   if (m_status & CARD_SDHC)
     address *= 512;
   return address;
 }
 
-void SDIOSlot0::InitSDHC()
+void SDIOSlot0Device::InitSDHC()
 {
   m_protocol = SDProtocol::V2;
   m_status |= CARD_INITIALIZED;
 }
 
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/SDIO/SDIOSlot0.h b/Source/Core/Core/IOS/SDIO/SDIOSlot0.h
@@ -16,13 +16,13 @@
 
 class PointerWrap;
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
 // The front SD slot
-class SDIOSlot0 : public Device
+class SDIOSlot0Device : public Device
 {
 public:
-  SDIOSlot0(Kernel& ios, const std::string& device_name);
+  SDIOSlot0Device(Kernel& ios, const std::string& device_name);
 
   void DoState(PointerWrap& p) override;
 
@@ -164,4 +164,4 @@ class SDIOSlot0 : public Device
 
   File::IOFile m_card;
 };
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/STM/STM.cpp b/Source/Core/Core/IOS/STM/STM.cpp
@@ -12,11 +12,11 @@
 #include "Core/Core.h"
 #include "Core/HW/Memmap.h"
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
 static std::unique_ptr<IOCtlRequest> s_event_hook_request;
 
-IPCCommandResult STMImmediate::IOCtl(const IOCtlRequest& request)
+IPCCommandResult STMImmediateDevice::IOCtl(const IOCtlRequest& request)
 {
   s32 return_value = IPC_SUCCESS;
   switch (request.request)
@@ -62,12 +62,12 @@ IPCCommandResult STMImmediate::IOCtl(const IOCtlRequest& request)
   return GetDefaultReply(return_value);
 }
 
-STMEventHook::~STMEventHook()
+STMEventHookDevice::~STMEventHookDevice()
 {
   s_event_hook_request.reset();
 }
 
-IPCCommandResult STMEventHook::IOCtl(const IOCtlRequest& request)
+IPCCommandResult STMEventHookDevice::IOCtl(const IOCtlRequest& request)
 {
   if (request.request != IOCTL_STM_EVENTHOOK)
     return GetDefaultReply(IPC_EINVAL);
@@ -80,7 +80,7 @@ IPCCommandResult STMEventHook::IOCtl(const IOCtlRequest& request)
   return GetNoReply();
 }
 
-void STMEventHook::DoState(PointerWrap& p)
+void STMEventHookDevice::DoState(PointerWrap& p)
 {
   u32 address = s_event_hook_request ? s_event_hook_request->address : 0;
   p.Do(address);
@@ -91,12 +91,12 @@ void STMEventHook::DoState(PointerWrap& p)
   Device::DoState(p);
 }
 
-bool STMEventHook::HasHookInstalled() const
+bool STMEventHookDevice::HasHookInstalled() const
 {
   return s_event_hook_request != nullptr;
 }
 
-void STMEventHook::TriggerEvent(const u32 event) const
+void STMEventHookDevice::TriggerEvent(const u32 event) const
 {
   // If the device isn't open, ignore the button press.
   if (!m_is_active || !s_event_hook_request)
@@ -107,14 +107,14 @@ void STMEventHook::TriggerEvent(const u32 event) const
   s_event_hook_request.reset();
 }
 
-void STMEventHook::ResetButton() const
+void STMEventHookDevice::ResetButton() const
 {
   // The reset button triggers STM_EVENT_RESET.
   TriggerEvent(STM_EVENT_RESET);
 }
 
-void STMEventHook::PowerButton() const
+void STMEventHookDevice::PowerButton() const
 {
   TriggerEvent(STM_EVENT_POWER);
 }
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/STM/STM.h b/Source/Core/Core/IOS/STM/STM.h
@@ -12,7 +12,7 @@
 
 class PointerWrap;
 
-namespace IOS::HLE::Device
+namespace IOS::HLE
 {
 enum
 {
@@ -39,19 +39,19 @@ enum
 };
 
 // The /dev/stm/immediate
-class STMImmediate final : public Device
+class STMImmediateDevice final : public Device
 {
 public:
   using Device::Device;
   IPCCommandResult IOCtl(const IOCtlRequest& request) override;
 };
 
 // The /dev/stm/eventhook
-class STMEventHook final : public Device
+class STMEventHookDevice final : public Device
 {
 public:
   using Device::Device;
-  ~STMEventHook() override;
+  ~STMEventHookDevice() override;
   IPCCommandResult IOCtl(const IOCtlRequest& request) override;
   void DoState(PointerWrap& p) override;
 
@@ -62,4 +62,4 @@ class STMEventHook final : public Device
 private:
   void TriggerEvent(u32 event) const;
 };
-}  // namespace IOS::HLE::Device
+}  // namespace IOS::HLE
diff --git a/Source/Core/Core/IOS/USB/Bluetooth/BTBase.h b/Source/Core/Core/IOS/USB/Bluetooth/BTBase.h
@@ -19,9 +19,7 @@ namespace IOS::HLE
 void BackUpBTInfoSection(const SysConf* sysconf);
 void RestoreBTInfoSection(SysConf* sysconf);
 
-namespace Device
-{
-class BluetoothBase : public Device
+class BluetoothBaseDevice : public Device
 {
 public:
   using Device::Device;
@@ -43,5 +41,4 @@ class BluetoothBase : public Device
     ACL_DATA_OUT = 0x02
   };
 };
-}  // namespace Device
 }  // namespace IOS::HLE