diff --git a/vita3k/Windows.manifest b/vita3k/Windows.manifest
index 8079b158b0..ed33533ad5 100644
--- a/vita3k/Windows.manifest
+++ b/vita3k/Windows.manifest
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <!-- 
 Vita3K emulator project
-Copyright (C) 2021 Vita3K team
+Copyright (C) 2024 Vita3K team
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
diff --git a/vita3k/config/include/config/config.h b/vita3k/config/include/config/config.h
index 7825d64e8e..855dcc1696 100644
--- a/vita3k/config/include/config/config.h
+++ b/vita3k/config/include/config/config.h
@@ -91,8 +91,8 @@ enum ScreenshotFormat {
     code(bool, "ngs-enable", true, ngs_enable)                                                          \
     code(int, "sys-button", static_cast<int>(SCE_SYSTEM_PARAM_ENTER_BUTTON_CROSS), sys_button)          \
     code(int, "sys-lang", static_cast<int>(SCE_SYSTEM_PARAM_LANG_ENGLISH_US), sys_lang)                 \
-    code(int, "sys-date-format", (int)SCE_SYSTEM_PARAM_DATE_FORMAT_MMDDYYYY, sys_date_format)           \
-    code(int, "sys-time-format", (int)SCE_SYSTEM_PARAM_TIME_FORMAT_12HOUR, sys_time_format)             \
+    code(int, "sys-date-format", static_cast<int>(SCE_SYSTEM_PARAM_DATE_FORMAT_MMDDYYYY), sys_date_format)\
+    code(int, "sys-time-format", static_cast<int>(SCE_SYSTEM_PARAM_TIME_FORMAT_12HOUR), sys_time_format)\
     code(int, "cpu-pool-size", 10, cpu_pool_size)                                                       \
     code(int, "modules-mode", static_cast<int>(ModulesMode::AUTOMATIC), modules_mode)                   \
     code(int, "delay-background", 4, delay_background)                                                  \
diff --git a/vita3k/gui/src/gui.cpp b/vita3k/gui/src/gui.cpp
index 20b0023b64..7549ec180f 100644
--- a/vita3k/gui/src/gui.cpp
+++ b/vita3k/gui/src/gui.cpp
@@ -239,7 +239,7 @@ static void init_font(GuiState &gui, EmuEnvState &emuenv) {
         large_font_config.SizePixels = 116.f;
         gui.large_font = io.Fonts->AddFontFromFileTTF(fs_utils::path_to_utf8(latin_fw_font_path).c_str(), large_font_config.SizePixels, &large_font_config, large_font_chars);
     } else {
-        LOG_WARN("Could not find firmware font file at \"{}\", install firmware fonts package to fix this.", latin_fw_font_path);
+        LOG_WARN("Could not find firmware font file at {}, install firmware fonts package to fix this.", latin_fw_font_path);
         font_config.SizePixels = 22.f;
 
         // Set up default font path
@@ -261,7 +261,7 @@ static void init_font(GuiState &gui, EmuEnvState &emuenv) {
 
             LOG_INFO("Using default Vita3K font.");
         } else
-            LOG_WARN("Could not find default Vita3K font at \"{}\", using default ImGui font.", default_font_path);
+            LOG_WARN("Could not find default Vita3K font at {}, using default ImGui font.", default_font_path);
     }
 
     // Build font atlas loaded and upload to GPU
@@ -423,18 +423,18 @@ static bool get_user_apps(GuiState &gui, EmuEnvState &emuenv) {
         gui.app_selector.user_apps.clear();
         // Read size of apps list
         size_t size;
-        apps_cache.read((char *)&size, sizeof(size));
+        apps_cache.read(reinterpret_cast<char *>(&size), sizeof(size));
 
         // Check version of cache
         uint32_t versionInFile;
-        apps_cache.read((char *)&versionInFile, sizeof(uint32_t));
+        apps_cache.read(reinterpret_cast<char *>(&versionInFile), sizeof(uint32_t));
         if (versionInFile != 1) {
             LOG_WARN("Current version of cache: {}, is outdated, recreate it.", versionInFile);
             return false;
         }
 
         // Read language of cache
-        apps_cache.read((char *)&gui.app_selector.apps_cache_lang, sizeof(uint32_t));
+        apps_cache.read(reinterpret_cast<char *>(&gui.app_selector.apps_cache_lang), sizeof(uint32_t));
         if (gui.app_selector.apps_cache_lang != emuenv.cfg.sys_lang) {
             LOG_WARN("Current lang of cache: {}, is different configuration: {}, recreate it.", get_sys_lang_name(gui.app_selector.apps_cache_lang), get_sys_lang_name(emuenv.cfg.sys_lang));
             return false;
@@ -445,7 +445,7 @@ static bool get_user_apps(GuiState &gui, EmuEnvState &emuenv) {
             auto read = [&apps_cache]() {
                 size_t size;
 
-                apps_cache.read((char *)&size, sizeof(size));
+                apps_cache.read(reinterpret_cast<char *>(&size), sizeof(size));
 
                 std::vector<char> buffer(size); // dont trust std::string to hold buffer enough
                 apps_cache.read(buffer.data(), size);
@@ -488,18 +488,18 @@ void save_apps_cache(GuiState &gui, EmuEnvState &emuenv) {
 
         // Write version of cache
         const uint32_t versionInFile = 1;
-        apps_cache.write((const char *)&versionInFile, sizeof(uint32_t));
+        apps_cache.write(reinterpret_cast<const char *>(&versionInFile), sizeof(uint32_t));
 
         // Write language of cache
         gui.app_selector.apps_cache_lang = emuenv.cfg.sys_lang;
-        apps_cache.write((char *)&gui.app_selector.apps_cache_lang, sizeof(uint32_t));
+        apps_cache.write(reinterpret_cast<char *>(&gui.app_selector.apps_cache_lang), sizeof(uint32_t));
 
         // Write Apps list
         for (const App &app : gui.app_selector.user_apps) {
             auto write = [&apps_cache](const std::string &i) {
                 const auto size = i.length();
 
-                apps_cache.write((const char *)&size, sizeof(size));
+                apps_cache.write(reinterpret_cast<const char *>(&size), sizeof(size));
                 apps_cache.write(i.c_str(), size);
             };
 
diff --git a/vita3k/gui/src/manual.cpp b/vita3k/gui/src/manual.cpp
index 8b2eb8343e..ff3425b330 100644
--- a/vita3k/gui/src/manual.cpp
+++ b/vita3k/gui/src/manual.cpp
@@ -223,7 +223,7 @@ void draw_manual(GuiState &gui, EmuEnvState &emuenv) {
     }
 
     // Draw right button
-    if (current_page < (int)gui.manuals.size() - 1) {
+    if (current_page < static_cast<int>(gui.manuals.size()) - 1) {
         ImGui::SetCursorPos(ImVec2(display_size.x - (70.f * SCALE.x), display_size.y - (40.0f * SCALE.y)));
         if ((!hidden_button && ImGui::Button(">", BUTTON_SIZE)) || ImGui::IsKeyPressed(static_cast<ImGuiKey>(emuenv.cfg.keyboard_leftstick_right))) {
             scroll = 0.f;
diff --git a/vita3k/gui/src/trophy_collection.cpp b/vita3k/gui/src/trophy_collection.cpp
index 128bcfbf8e..e3f310e327 100644
--- a/vita3k/gui/src/trophy_collection.cpp
+++ b/vita3k/gui/src/trophy_collection.cpp
@@ -102,19 +102,19 @@ static bool load_trophy_progress(IOState &io, const SceUID &progress_input_file,
     }
 
     // Read trophy count by group
-    if (read_trophy_progress_file(np_com_id_info[np_com_id].context.trophy_count_by_group.data(), (uint32_t)np_com_id_info[np_com_id].context.trophy_count_by_group.size() * 4) != (int)np_com_id_info[np_com_id].context.trophy_count_by_group.size() * 4) {
+    if (read_trophy_progress_file(np_com_id_info[np_com_id].context.trophy_count_by_group.data(), (uint32_t)np_com_id_info[np_com_id].context.trophy_count_by_group.size() * 4) != static_cast<int>(np_com_id_info[np_com_id].context.trophy_count_by_group.size()) * 4) {
         LOG_ERROR("Fail read trophy count by group");
         return false;
     }
 
     // Read trophy timestamps
-    if (read_trophy_progress_file(np_com_id_info[np_com_id].context.unlock_timestamps.data(), (uint32_t)np_com_id_info[np_com_id].context.unlock_timestamps.size() * 8) != (int)np_com_id_info[np_com_id].context.unlock_timestamps.size() * 8) {
+    if (read_trophy_progress_file(np_com_id_info[np_com_id].context.unlock_timestamps.data(), (uint32_t)np_com_id_info[np_com_id].context.unlock_timestamps.size() * 8) != static_cast<int>(np_com_id_info[np_com_id].context.unlock_timestamps.size()) * 8) {
         LOG_ERROR("Fail read unlock_timestamp");
         return false;
     }
 
     // Read trophy type
-    if (read_trophy_progress_file(np_com_id_info[np_com_id].context.trophy_kinds.data(), (uint32_t)np_com_id_info[np_com_id].context.trophy_kinds.size() * 4) != (int)np_com_id_info[np_com_id].context.trophy_kinds.size() * 4) {
+    if (read_trophy_progress_file(np_com_id_info[np_com_id].context.trophy_kinds.data(), (uint32_t)np_com_id_info[np_com_id].context.trophy_kinds.size() * 4) != static_cast<int>(np_com_id_info[np_com_id].context.trophy_kinds.size()) * 4) {
         LOG_ERROR("Fail read trophy type");
         return false;
     }
diff --git a/vita3k/kernel/src/sync_primitives.cpp b/vita3k/kernel/src/sync_primitives.cpp
index e8ee473e24..5f5f62de0e 100644
--- a/vita3k/kernel/src/sync_primitives.cpp
+++ b/vita3k/kernel/src/sync_primitives.cpp
@@ -1842,7 +1842,7 @@ SceSize msgpipe_send(KernelState &kernel, const char *export_name, SceUID thread
             SceSize insertedSize = (SceSize)msgpipe->data_buffer.Insert(pSendBuf, sendSize);
             // msgpipe->senders->erase(wait_data); //Don't erase ourselves - recv will do it
             wakeup_receivers();
-            return (int)insertedSize;
+            return static_cast<int>(insertedSize);
         };
 
         if (!pTimeout) { // No timeout - loop forever until we can fill the buffer
diff --git a/vita3k/modules/SceHttp/SceHttp.cpp b/vita3k/modules/SceHttp/SceHttp.cpp
index 7d6f698525..df1e257498 100644
--- a/vita3k/modules/SceHttp/SceHttp.cpp
+++ b/vita3k/modules/SceHttp/SceHttp.cpp
@@ -229,7 +229,7 @@ EXPORT(SceInt, sceHttpCreateConnectionWithURL, SceInt tmplId, const char *url, S
         }
         case SCE_HTTP_ERROR_OUT_OF_SIZE: return RET_ERROR(SCE_HTTP_ERROR_OUT_OF_SIZE);
         default:
-            LOG_WARN("Returning missing case of parse_url {}", (int)parseRet);
+            LOG_WARN("Returning missing case of parse_url {}", static_cast<int>(parseRet));
             assert(false);
             return parseRet;
         }
@@ -332,7 +332,7 @@ EXPORT(SceInt, sceHttpCreateConnectionWithURL, SceInt tmplId, const char *url, S
 
         long verify_flag = SSL_get_verify_result((SSL *)tmpl->second.ssl);
         if (verify_flag != X509_V_OK && verify_flag != X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY)
-            LOG_ERROR("Certificate verification error ({}) but continuing...\n", (int)verify_flag);
+            LOG_ERROR("Certificate verification error ({}) but continuing...\n", static_cast<int>(verify_flag));
     }
 
     emuenv.http.connections.emplace(connId, SceConnection{ tmplId, urlStr, enableKeepalive, isSecure, sockfd });
@@ -411,7 +411,7 @@ EXPORT(SceInt, sceHttpCreateRequestWithURL, SceInt connId, SceHttpMethods method
         }
         case SCE_HTTP_ERROR_OUT_OF_SIZE: return RET_ERROR(SCE_HTTP_ERROR_OUT_OF_SIZE);
         default:
-            LOG_WARN("Returning missing case of parse_url {}", (int)parseRet);
+            LOG_WARN("Returning missing case of parse_url {}", static_cast<int>(parseRet));
             assert(false);
             return parseRet;
         }
@@ -1451,7 +1451,7 @@ EXPORT(SceInt, sceHttpUriParse, SceHttpUriElement *out, const char *srcUrl, Ptr<
         }
         case SCE_HTTP_ERROR_OUT_OF_SIZE: return RET_ERROR(SCE_HTTP_ERROR_OUT_OF_SIZE);
         default:
-            LOG_WARN("Returning missing case of parse_url {}", (int)parseRet);
+            LOG_WARN("Returning missing case of parse_url {}", static_cast<int>(parseRet));
             assert(false);
             return parseRet;
         }
diff --git a/vita3k/modules/SceLibKernel/SceLibKernel.cpp b/vita3k/modules/SceLibKernel/SceLibKernel.cpp
index 95245bd0c2..7bd95d378e 100644
--- a/vita3k/modules/SceLibKernel/SceLibKernel.cpp
+++ b/vita3k/modules/SceLibKernel/SceLibKernel.cpp
@@ -183,7 +183,7 @@ EXPORT(Ptr<void>, sceClibMemcpy_safe, Ptr<void> dst, const Ptr<void> src, SceSiz
         CALL_EXPORT(sceClibMemcpy, dst, src.get(emuenv.mem), len);
         return dst;
     }
-    const auto diff = std::abs((int)(src.address() - dst.address()));
+    const auto diff = std::abs(static_cast<int>(src.address() - dst.address()));
     if (len > diff) {
         LOG_ERROR("sceClibMemcpy({},{},{}) src/dst overlap", log_hex_full(src.address()), log_hex_full(dst.address()), len);
         assert(false);
diff --git a/vita3k/modules/SceNet/SceNet.cpp b/vita3k/modules/SceNet/SceNet.cpp
index f9d05b36c1..eb1ab8f994 100644
--- a/vita3k/modules/SceNet/SceNet.cpp
+++ b/vita3k/modules/SceNet/SceNet.cpp
@@ -476,7 +476,7 @@ EXPORT(int, sceNetResolverGetError) {
 
 EXPORT(int, sceNetResolverStartAton, int rid, const SceNetInAddr *addr, char *hostname, int len, int timeout, int retry, int flags) {
     TRACY_FUNC(sceNetResolverStartAton, rid, addr, hostname, len, timeout, retry, flags);
-    struct hostent *resolved = gethostbyaddr((const char *)addr, len, AF_INET);
+    struct hostent *resolved = gethostbyaddr(reinterpret_cast<const char *>(addr), len, AF_INET);
     strcpy(hostname, resolved->h_name);
     return 0;
 }
diff --git a/vita3k/net/src/posixsocket.cpp b/vita3k/net/src/posixsocket.cpp
index 84a5ad53f4..bae21de273 100644
--- a/vita3k/net/src/posixsocket.cpp
+++ b/vita3k/net/src/posixsocket.cpp
@@ -318,7 +318,7 @@ int PosixSocket::get_socket_options(int level, int optname, void *optval, unsign
             CASE_GETSOCKOPT_VALUE(SCE_NET_SO_USECRYPTO, sockopt_so_usecrypto);
             CASE_GETSOCKOPT_VALUE(SCE_NET_SO_USESIGNATURE, sockopt_so_usesignature);
             CASE_GETSOCKOPT_VALUE(SCE_NET_SO_TPPOLICY, sockopt_so_tppolicy);
-            CASE_GETSOCKOPT_VALUE(SCE_NET_SO_NAME, (char)0); // writes an empty string to the output buffer
+            CASE_GETSOCKOPT_VALUE(SCE_NET_SO_NAME, static_cast<char>(0)); // writes an empty string to the output buffer
         }
     } else if (level == IPPROTO_IP) {
         switch (optname) {
@@ -346,13 +346,13 @@ int PosixSocket::get_socket_options(int level, int optname, void *optval, unsign
 int PosixSocket::recv_packet(void *buf, unsigned int len, int flags, SceNetSockaddr *from, unsigned int *fromlen) {
     if (from != nullptr) {
         sockaddr addr;
-        int res = recvfrom(sock, (char *)buf, len, flags, &addr, (socklen_t *)fromlen);
+        int res = recvfrom(sock, static_cast<char *>(buf), len, flags, &addr, (socklen_t *)fromlen);
         convertPosixSockaddrToSce(&addr, from);
         *fromlen = sizeof(SceNetSockaddrIn);
 
         return translate_return_value(res);
     } else {
-        return translate_return_value(recv(sock, (char *)buf, len, flags));
+        return translate_return_value(recv(sock, static_cast<char *>(buf), len, flags));
     }
 }
 
@@ -360,8 +360,8 @@ int PosixSocket::send_packet(const void *msg, unsigned int len, int flags, const
     if (to != nullptr) {
         sockaddr addr;
         convertSceSockaddrToPosix(to, &addr);
-        return translate_return_value(sendto(sock, (const char *)msg, len, flags, &addr, sizeof(sockaddr_in)));
+        return translate_return_value(sendto(sock, static_cast<const char *>(msg), len, flags, &addr, sizeof(sockaddr_in)));
     } else {
-        return translate_return_value(send(sock, (const char *)msg, len, flags));
+        return translate_return_value(send(sock, static_cast<const char *>(msg), len, flags));
     }
 }
diff --git a/vita3k/np/src/trophy/context.cpp b/vita3k/np/src/trophy/context.cpp
index 6ece7f46b1..f79d9b9fa2 100644
--- a/vita3k/np/src/trophy/context.cpp
+++ b/vita3k/np/src/trophy/context.cpp
@@ -212,15 +212,15 @@ bool Context::load_trophy_progress_file(const SceUID &progress_input_file) {
         return false;
 
     // Read trophy count by group
-    if (read_stuff(trophy_count_by_group.data(), (std::uint32_t)trophy_count_by_group.size() * 4) != (int)trophy_count_by_group.size() * 4)
+    if (read_stuff(trophy_count_by_group.data(), static_cast<std::uint32_t>(trophy_count_by_group.size()) * 4) != static_cast<int>(trophy_count_by_group.size()) * 4)
         return false;
 
     // Read timestamps
-    if (read_stuff(unlock_timestamps.data(), (std::uint32_t)unlock_timestamps.size() * 8) != (int)unlock_timestamps.size() * 8)
+    if (read_stuff(unlock_timestamps.data(), static_cast<std::uint32_t>(unlock_timestamps.size()) * 8) != static_cast<int>(unlock_timestamps.size()) * 8)
         return false;
 
     // Read trophy type (shinyyyy!! *yes this is lord of the ring reference*)
-    if (read_stuff(trophy_kinds.data(), (std::uint32_t)trophy_kinds.size() * 4) != (int)trophy_kinds.size() * 4)
+    if (read_stuff(trophy_kinds.data(), static_cast<std::uint32_t>(trophy_kinds.size()) * 4) != static_cast<int>(trophy_kinds.size()) * 4)
         return false;
 
     return true;
diff --git a/vita3k/packages/src/license.cpp b/vita3k/packages/src/license.cpp
index 1bdec13466..2ebf0f237f 100644
--- a/vita3k/packages/src/license.cpp
+++ b/vita3k/packages/src/license.cpp
@@ -56,7 +56,7 @@ static bool open_license(const fs::path &license_path, SceNpDrmLicense &license_
     memset(&license_buf, 0, sizeof(SceNpDrmLicense));
     fs::ifstream license(license_path, std::ios::in | std::ios::binary);
     if (license.is_open()) {
-        license.read((char *)&license_buf, sizeof(SceNpDrmLicense));
+        license.read(reinterpret_cast<char *>(&license_buf), sizeof(SceNpDrmLicense));
         license.close();
         return true;
     }
diff --git a/vita3k/packages/src/pkg.cpp b/vita3k/packages/src/pkg.cpp
index b8583be611..7185d19bd3 100644
--- a/vita3k/packages/src/pkg.cpp
+++ b/vita3k/packages/src/pkg.cpp
@@ -121,7 +121,7 @@ bool install_pkg(const fs::path &pkg_path, EmuEnvState &emuenv, std::string &p_z
     for (uint32_t i = 0; i < byte_swap(pkg_header.info_count); i++) {
         uint32_t block[4];
         infile.seekg(info_offset);
-        infile.read((char *)block, sizeof(block));
+        infile.read(reinterpret_cast<char *>(block), sizeof(block));
 
         auto type = byte_swap(block[0]);
         auto size = byte_swap(block[1]);
@@ -202,7 +202,7 @@ bool install_pkg(const fs::path &pkg_path, EmuEnvState &emuenv, std::string &p_z
     std::vector<uint8_t> sfo_buffer(sfo_size);
     SfoFile sfo_file;
     infile.seekg(sfo_offset);
-    infile.read((char *)&sfo_buffer[0], sfo_size);
+    infile.read(reinterpret_cast<char *>(&sfo_buffer[0]), sfo_size);
     sfo::load(sfo_file, sfo_buffer);
     sfo::get_param_info(emuenv.app_info, sfo_buffer, emuenv.cfg.sys_lang);
 
@@ -259,11 +259,11 @@ bool install_pkg(const fs::path &pkg_path, EmuEnvState &emuenv, std::string &p_z
             evp_cleanup();
             return false;
         }
-        const auto file_count = (float)byte_swap(pkg_header.file_count);
+        const auto file_count = static_cast<float>(byte_swap(pkg_header.file_count));
         progress_callback(i / file_count * 100.f * 0.6f);
         std::vector<unsigned char> name(byte_swap(entry.name_size));
         infile.seekg(byte_swap(pkg_header.data_offset) + byte_swap(entry.name_offset));
-        infile.read((char *)&name[0], byte_swap(entry.name_size));
+        infile.read(reinterpret_cast<char *>(&name[0]), byte_swap(entry.name_size));
 
         decrypt_aes_ctr(byte_swap(entry.name_offset) / 16, name.data(), byte_swap(entry.name_size));
 
diff --git a/vita3k/packages/src/pup.cpp b/vita3k/packages/src/pup.cpp
index 328e7b272f..a19dd1dc0e 100644
--- a/vita3k/packages/src/pup.cpp
+++ b/vita3k/packages/src/pup.cpp
@@ -183,7 +183,7 @@ static void decrypt_segments(std::ifstream &infile, const fs::path &outdir, cons
         fs::ofstream outfile(outdir / fs_utils::path_concat(filename, ".seg02"), std::ios::binary);
         infile.seekg(sceseg.offset);
         std::vector<unsigned char> encrypted_data(sceseg.size);
-        infile.read((char *)&encrypted_data[0], sceseg.size);
+        infile.read(reinterpret_cast<char *>(&encrypted_data[0]), sceseg.size);
 
         std::vector<unsigned char> decrypted_data(sceseg.size);
         EVP_DecryptInit_ex(cipher_ctx, cipher, nullptr, reinterpret_cast<const unsigned char *>(sceseg.key.c_str()), reinterpret_cast<const unsigned char *>(sceseg.iv.c_str()));
@@ -195,7 +195,7 @@ static void decrypt_segments(std::ifstream &infile, const fs::path &outdir, cons
             const std::string decompressed_data = decompress_segments(decrypted_data, sceseg.size);
             outfile.write(decompressed_data.c_str(), decompressed_data.size());
         } else {
-            outfile.write((char *)&decrypted_data[0], sceseg.size);
+            outfile.write(reinterpret_cast<char *>(&decrypted_data[0]), sceseg.size);
         }
         outfile.close();
     }
diff --git a/vita3k/packages/src/sce_utils.cpp b/vita3k/packages/src/sce_utils.cpp
index 443e675966..aaabf1598f 100644
--- a/vita3k/packages/src/sce_utils.cpp
+++ b/vita3k/packages/src/sce_utils.cpp
@@ -632,7 +632,7 @@ static void traverse_directory(Fat16::Image &img, Fat16::Entry mee, const fs::pa
     fs::create_directories(dir_path);
 
     while (img.get_next_entry(mee)) {
-        if (mee.entry.file_attributes & (int)Fat16::EntryAttribute::DIRECTORY) {
+        if (mee.entry.file_attributes & static_cast<int>(Fat16::EntryAttribute::DIRECTORY)) {
             // Also check if it's not the back folder (. and ..)
             // This can be done by gathering the name
             if (mee.entry.get_entry_type_from_filename() != Fat16::EntryType::DIRECTORY) {
@@ -646,7 +646,7 @@ static void traverse_directory(Fat16::Image &img, Fat16::Entry mee, const fs::pa
             }
         }
 
-        if (mee.entry.file_attributes & (int)Fat16::EntryAttribute::ARCHIVE) {
+        if (mee.entry.file_attributes & static_cast<int>(Fat16::EntryAttribute::ARCHIVE)) {
             extract_file(img, mee, dir_path / "");
         }
     }
@@ -685,7 +685,7 @@ std::string decompress_segments(const std::vector<uint8_t> &decrypted_data, cons
         return "";
     }
 
-    const std::string compressed_data((char *)&decrypted_data[0], size);
+    const std::string compressed_data((char *)(&decrypted_data[0]), size);
     stream.next_in = (const Bytef *)compressed_data.data();
     stream.avail_in = compressed_data.size();
 
@@ -834,7 +834,7 @@ void self2elf(const fs::path &infile, const fs::path &outfile, KeyStore &SCE_KEY
 
         filein.seekg(segment_infos[idx].offset);
         std::vector<unsigned char> dat(segment_infos[idx].size);
-        filein.read((char *)&dat[0], segment_infos[idx].size);
+        filein.read(reinterpret_cast<char *>(&dat[0]), segment_infos[idx].size);
 
         std::vector<unsigned char> decrypted_data(segment_infos[idx].size);
         if (segment_infos[idx].plaintext == SecureBool::NO) {
@@ -850,7 +850,7 @@ void self2elf(const fs::path &infile, const fs::path &outfile, KeyStore &SCE_KEY
             fileout.write(decompressed_data.c_str(), decompressed_data.length());
             at += decompressed_data.length();
         } else {
-            fileout.write((char *)&decrypted_data[0], segment_infos[idx].size);
+            fileout.write(reinterpret_cast<char *>(&decrypted_data[0]), segment_infos[idx].size);
             at += segment_infos[idx].size;
         }
     }
@@ -936,17 +936,17 @@ void make_fself(const fs::path &input_file, const fs::path &output_file, uint64_
     myhdr.e_phnum = ehdr.e_phnum;
 
     fileout.seekp(hdr.appinfo_offset, std::ios_base::beg);
-    fileout.write((char *)&appinfo, sizeof(appinfo));
+    fileout.write(reinterpret_cast<char *>(&appinfo), sizeof(appinfo));
 
     fileout.seekp(hdr.elf_offset, std::ios_base::beg);
-    fileout.write((char *)&myhdr, ElfHeader::Size);
+    fileout.write(reinterpret_cast<char *>(&myhdr), ElfHeader::Size);
 
     fileout.seekp(hdr.phdr_offset, std::ios_base::beg);
     for (int i = 0; i < ehdr.e_phnum; ++i) {
         ElfPhdr phdr = ElfPhdr(&input[0] + ehdr.e_phoff + ehdr.e_phentsize * i);
         if (phdr.p_align > 0x1000)
             phdr.p_align = 0x1000;
-        fileout.write((char *)&phdr, sizeof(phdr));
+        fileout.write(reinterpret_cast<char *>(&phdr), sizeof(phdr));
     }
 
     fileout.seekp(hdr.section_info_offset, std::ios_base::beg);
@@ -957,16 +957,16 @@ void make_fself(const fs::path &input_file, const fs::path &output_file, uint64_
         segment_info.length = phdr.p_filesz;
         segment_info.compression = 1;
         segment_info.encryption = 2;
-        fileout.write((char *)&segment_info, sizeof(segment_info));
+        fileout.write(reinterpret_cast<char *>(&segment_info), sizeof(segment_info));
     }
 
     fileout.seekp(hdr.sceversion_offset, std::ios_base::beg);
-    fileout.write((char *)&ver, sizeof(ver));
+    fileout.write(reinterpret_cast<char *>(&ver), sizeof(ver));
 
     fileout.seekp(hdr.controlinfo_offset, std::ios_base::beg);
-    fileout.write((char *)&control_5, sizeof(control_5));
-    fileout.write((char *)&control_6, sizeof(control_6));
-    fileout.write((char *)&control_7, sizeof(control_7));
+    fileout.write(reinterpret_cast<char *>(&control_5), sizeof(control_5));
+    fileout.write(reinterpret_cast<char *>(&control_6), sizeof(control_6));
+    fileout.write(reinterpret_cast<char *>(&control_7), sizeof(control_7));
 
     fileout.seekp(HEADER_LEN, std::ios_base::beg);
     fileout.write(&input[0], file_size);
@@ -975,7 +975,7 @@ void make_fself(const fs::path &input_file, const fs::path &output_file, uint64_
     hdr.self_filesize = fileout.tellp();
     fileout.seekp(0, std::ios_base::beg);
 
-    fileout.write((char *)&hdr, sizeof(hdr));
+    fileout.write(reinterpret_cast<char *>(&hdr), sizeof(hdr));
 
     fileout.close();
 }
@@ -1029,7 +1029,7 @@ std::vector<SceSegment> get_segments(std::ifstream &file, const SceHeader &sce_h
     EVP_DecryptUpdate(cipher_ctx, dec, &dec_len, dec_in, MetadataInfo::Size);
     EVP_DecryptFinal_ex(cipher_ctx, dec + dec_len, &dec_len);
 
-    MetadataInfo metadata_info = MetadataInfo((char *)dec);
+    MetadataInfo metadata_info = MetadataInfo(reinterpret_cast<char *>(dec));
 
     std::vector<unsigned char> dec1(sce_hdr.header_length - sce_hdr.metadata_offset - 48 - MetadataInfo::Size);
     std::vector<unsigned char> input_data(sce_hdr.header_length - sce_hdr.metadata_offset - 48 - MetadataInfo::Size);
@@ -1041,7 +1041,7 @@ std::vector<SceSegment> get_segments(std::ifstream &file, const SceHeader &sce_h
 
     unsigned char dec2[MetadataHeader::Size];
     std::copy(&dec1[0], &dec1[MetadataHeader::Size], dec2);
-    MetadataHeader metadata_hdr = MetadataHeader((char *)dec2);
+    MetadataHeader metadata_hdr = MetadataHeader(reinterpret_cast<char *>(dec2));
 
     std::vector<SceSegment> segs;
     const auto start = MetadataHeader::Size + metadata_hdr.section_count * MetadataSection::Size;
@@ -1055,7 +1055,7 @@ std::vector<SceSegment> get_segments(std::ifstream &file, const SceHeader &sce_h
     for (uint32_t i = 0; i < metadata_hdr.section_count; i++) {
         std::vector<unsigned char> dec3((MetadataHeader::Size + i * MetadataSection::Size + MetadataSection::Size) - (MetadataHeader::Size + i * MetadataSection::Size));
         memcpy(&dec3[0], &dec1[0] + (MetadataHeader::Size + i * MetadataSection::Size), (MetadataHeader::Size + i * MetadataSection::Size + MetadataSection::Size) - (MetadataHeader::Size + i * MetadataSection::Size));
-        MetadataSection metsec = MetadataSection((char *)&dec3[0]);
+        MetadataSection metsec = MetadataSection(reinterpret_cast<char *>(&dec3[0]));
 
         if (metsec.encryption == EncryptionType::AES128CTR) {
             segs.push_back({ metsec.offset, metsec.seg_idx, metsec.size, metsec.compression == CompressionType::DEFLATE, vault[metsec.key_idx], vault[metsec.iv_idx] });
diff --git a/vita3k/renderer/src/gl/renderer.cpp b/vita3k/renderer/src/gl/renderer.cpp
index d25a701884..16b5625dd4 100644
--- a/vita3k/renderer/src/gl/renderer.cpp
+++ b/vita3k/renderer/src/gl/renderer.cpp
@@ -519,7 +519,7 @@ static void post_process_pixels_data(GLState &renderer, std::uint32_t *pixels, s
                 const size_t first_pixel_offset_in_linear = (j * stride) + hori_tile * 32;
 
                 memcpy(buffer.data() + first_pixel_offset_in_tile * bytes_per_pixel,
-                    (const char *)(pixels) + first_pixel_offset_in_linear * bytes_per_pixel, 32 * bytes_per_pixel);
+                    reinterpret_cast<const char *>(pixels) + first_pixel_offset_in_linear * bytes_per_pixel, 32 * bytes_per_pixel);
             }
         }
         memcpy(pixels, buffer.data(), buffer.size());
diff --git a/vita3k/renderer/src/shaders.cpp b/vita3k/renderer/src/shaders.cpp
index 3f0a8f1c95..0d5d04664c 100644
--- a/vita3k/renderer/src/shaders.cpp
+++ b/vita3k/renderer/src/shaders.cpp
@@ -42,13 +42,13 @@ bool get_shaders_cache_hashs(State &renderer) {
     renderer.shaders_cache_hashs.clear();
     // Read size of hashes list
     size_t size;
-    shaders_hashs.read((char *)&size, sizeof(size));
+    shaders_hashs.read(reinterpret_cast<char *>(&size), sizeof(size));
 
     // Check version of cache and device id
     uint32_t versionInFile;
-    shaders_hashs.read((char *)&versionInFile, sizeof(uint32_t));
+    shaders_hashs.read(reinterpret_cast<char *>(&versionInFile), sizeof(uint32_t));
     uint32_t features_mask;
-    shaders_hashs.read((char *)&features_mask, sizeof(uint32_t));
+    shaders_hashs.read(reinterpret_cast<char *>(&features_mask), sizeof(uint32_t));
     if (versionInFile != shader::CURRENT_VERSION || features_mask != renderer.get_features_mask()) {
         shaders_hashs.close();
         fs::remove_all(renderer.shaders_path);
@@ -95,13 +95,13 @@ void save_shaders_cache_hashs(State &renderer, std::vector<ShadersHash> &shaders
     if (shaders_hashs.is_open()) {
         // Write Size of shaders cache hashes list
         const auto size = shaders_cache_hashs.size();
-        shaders_hashs.write((const char *)&size, sizeof(size));
+        shaders_hashs.write(reinterpret_cast<const char *>(&size), sizeof(size));
 
         // Write version of cache
         const uint32_t versionInFile = shader::CURRENT_VERSION;
-        shaders_hashs.write((const char *)&versionInFile, sizeof(uint32_t));
+        shaders_hashs.write(reinterpret_cast<const char *>(&versionInFile), sizeof(uint32_t));
         const uint32_t features_mask = renderer.get_features_mask();
-        shaders_hashs.write((const char *)&features_mask, sizeof(uint32_t));
+        shaders_hashs.write(reinterpret_cast<const char *>(&features_mask), sizeof(uint32_t));
 
         // Write shader hash list
         for (const auto &hash : shaders_cache_hashs) {
diff --git a/vita3k/renderer/src/vulkan/screen_filters.cpp b/vita3k/renderer/src/vulkan/screen_filters.cpp
index 905e5dc471..1f2c3489c2 100644
--- a/vita3k/renderer/src/vulkan/screen_filters.cpp
+++ b/vita3k/renderer/src/vulkan/screen_filters.cpp
@@ -218,10 +218,10 @@ void SinglePassScreenFilter::init() {
 void SinglePassScreenFilter::render(bool is_pre_renderpass, vk::ImageView src_img, vk::ImageLayout src_layout, const Viewport &viewport) {
     if (is_pre_renderpass) {
         std::array<float, 4> uvs = {
-            viewport.offset_x / (float)viewport.texture_width,
-            viewport.offset_y / (float)viewport.texture_height,
-            (viewport.offset_x + viewport.width) / (float)(viewport.texture_width),
-            (viewport.offset_y + viewport.height) / (float)(viewport.texture_height)
+            viewport.offset_x / static_cast<float>(viewport.texture_width),
+            viewport.offset_y / static_cast<float>(viewport.texture_height),
+            (viewport.offset_x + viewport.width) / static_cast<float>(viewport.texture_width),
+            (viewport.offset_y + viewport.height) / static_cast<float>(viewport.texture_height)
         };
 
         // if necessary update vao (should not happen often)
diff --git a/vita3k/shader/src/gxp_parser.cpp b/vita3k/shader/src/gxp_parser.cpp
index de13ac79b4..559489258d 100644
--- a/vita3k/shader/src/gxp_parser.cpp
+++ b/vita3k/shader/src/gxp_parser.cpp
@@ -507,4 +507,4 @@ uint8_t get_texture_component_count(SceGxmTextureFormat format) {
     }
 }
 
-} // namespace shader
\ No newline at end of file
+} // namespace shader
diff --git a/vita3k/shader/src/spirv_recompiler.cpp b/vita3k/shader/src/spirv_recompiler.cpp
index f63ae90d11..a7723258c6 100644
--- a/vita3k/shader/src/spirv_recompiler.cpp
+++ b/vita3k/shader/src/spirv_recompiler.cpp
@@ -1078,7 +1078,7 @@ static SpirvShaderParameters create_parameters(spv::Builder &b, const SceGxmProg
             // specialization constant for shader interlock:
             // layout (constant_id = GAMMA_CORRECTION_SPECIALIZATION_ID) const bool is_srgb = false;
             spv_params.is_srgb_constant = b.makeBoolConstant(false, true);
-            b.addDecoration(spv_params.is_srgb_constant, spv::DecorationSpecId, (int)GAMMA_CORRECTION_SPECIALIZATION_ID);
+            b.addDecoration(spv_params.is_srgb_constant, spv::DecorationSpecId, static_cast<int>(GAMMA_CORRECTION_SPECIALIZATION_ID));
             b.addName(spv_params.is_srgb_constant, "is_srgb");
         }
     }
@@ -1908,7 +1908,7 @@ static SpirvCode convert_gxp_to_spirv_impl(const SceGxmProgram &program, const s
     if (DUMP_SPIRV_BINARIES) {
         // TODO: use base path host var
         std::ofstream spirv_dump(shader_hash + ".spv", std::ios::binary);
-        spirv_dump.write((char *)&spirv, spirv.size() * sizeof(uint32_t));
+        spirv_dump.write(reinterpret_cast<char *>(&spirv), spirv.size() * sizeof(uint32_t));
         spirv_dump.close();
     }
 
diff --git a/vita3k/shader/src/translator/alu.cpp b/vita3k/shader/src/translator/alu.cpp
index 784f0d1233..b0c83ac89c 100644
--- a/vita3k/shader/src/translator/alu.cpp
+++ b/vita3k/shader/src/translator/alu.cpp
@@ -913,12 +913,12 @@ bool USSETranslatorVisitor::sop2(
     inst.opr.dest.type = DataType::UINT8;
 
     if (cop >= sizeof(operations) / sizeof(Opcode)) {
-        LOG_ERROR("Invalid color opcode: {}", (int)cop);
+        LOG_ERROR("Invalid color opcode: {}", static_cast<int>(cop));
         return true;
     }
 
     if (aop >= sizeof(operations) / sizeof(Opcode)) {
-        LOG_ERROR("Invalid alpha opcode: {}", (int)aop);
+        LOG_ERROR("Invalid alpha opcode: {}", static_cast<int>(aop));
         return true;
     }
 
@@ -1127,12 +1127,12 @@ bool shader::usse::USSETranslatorVisitor::sop2m(Imm2 pred,
     inst.opr.dest.type = DataType::UINT8;
 
     if (cop >= sizeof(operations) / sizeof(Opcode)) {
-        LOG_ERROR("Invalid color opcode: {}", (int)cop);
+        LOG_ERROR("Invalid color opcode: {}", static_cast<int>(cop));
         return true;
     }
 
     if (aop >= sizeof(operations) / sizeof(Opcode)) {
-        LOG_ERROR("Invalid alpha opcode: {}", (int)aop);
+        LOG_ERROR("Invalid alpha opcode: {}", static_cast<int>(aop));
         return true;
     }
 
@@ -1361,12 +1361,12 @@ bool shader::usse::USSETranslatorVisitor::sop3(Imm2 pred,
     inst.opr.dest.type = DataType::UINT8;
 
     if (cop >= sizeof(operations) / sizeof(Opcode)) {
-        LOG_ERROR("Invalid color opcode: {}", (int)cop);
+        LOG_ERROR("Invalid color opcode: {}", static_cast<int>(cop));
         return true;
     }
 
     if (aop >= sizeof(operations) / sizeof(Opcode)) {
-        LOG_ERROR("Invalid alpha opcode: {}", (int)aop);
+        LOG_ERROR("Invalid alpha opcode: {}", static_cast<int>(aop));
         return true;
     }
 
diff --git a/vita3k/shader/src/usse_disasm.cpp b/vita3k/shader/src/usse_disasm.cpp
index 37e097330f..a1fb9d6cfd 100644
--- a/vita3k/shader/src/usse_disasm.cpp
+++ b/vita3k/shader/src/usse_disasm.cpp
@@ -152,7 +152,7 @@ std::string reg_to_str(RegisterBank bank, uint32_t reg_num) {
         }
         }
 
-        opstr += "idx" + std::to_string((int)bank - (int)RegisterBank::INDEXED1 + 1) + " * 2 + " + std::to_string(add_off) + "]";
+        opstr += "idx" + std::to_string(static_cast<int>(bank) - static_cast<int>(RegisterBank::INDEXED1) + 1) + " * 2 + " + std::to_string(add_off) + "]";
 
         break;
     }
diff --git a/vita3k/shader/src/usse_utilities.cpp b/vita3k/shader/src/usse_utilities.cpp
index e437d9302d..d66b54137b 100644
--- a/vita3k/shader/src/usse_utilities.cpp
+++ b/vita3k/shader/src/usse_utilities.cpp
@@ -85,10 +85,10 @@ spv::Id finalize(spv::Builder &b, spv::Id first, spv::Id second, const Swizzle4
     // Try to plant a composite construct
     for (auto i = 0; i < 4; i++) {
         if (dest_mask & (1 << i)) {
-            if ((int)swizz[i] >= (int)SwizzleChannel::C_0) {
+            if (static_cast<int>(swizz[i]) >= static_cast<int>(SwizzleChannel::C_0)) {
                 ops.push_back(get_correspond_constant_with_channel(b, swizz[i]));
             } else if (offset_is_const) {
-                int access_offset = offset_value % 4 + (int)swizz[i] - (int)SwizzleChannel::C_X;
+                int access_offset = offset_value % 4 + static_cast<int>(swizz[i]) - static_cast<int>(SwizzleChannel::C_X);
                 spv::Id access_base = first;
 
                 if (access_offset >= first_comp_count) {
@@ -107,13 +107,13 @@ spv::Id finalize(spv::Builder &b, spv::Id first, spv::Id second, const Swizzle4
                     return spv::NoResult;
                 }
                 // do exactly as above, but in spirv
-                spv::Id delta = b.makeIntConstant((int)swizz[i] - (int)SwizzleChannel::C_X);
+                spv::Id delta = b.makeIntConstant(static_cast<int>(swizz[i]) - static_cast<int>(SwizzleChannel::C_X));
                 spv::Id access_offset = b.createBinOp(spv::OpIAdd, i32, offset, delta);
                 access_offset = b.createBinOp(spv::OpBitwiseAnd, i32, access_offset, b.makeIntConstant(3));
 
                 spv::Id first_base = b.createOp(spv::OpVectorExtractDynamic, target_type, { first, access_offset });
                 spv::Id second_base = b.createOp(spv::OpVectorExtractDynamic, target_type, { second, access_offset });
-                // select one if (int)swizz[i] - (int)SwizzleChannel::C_X < 4 - offset % 4
+                // select one if static_cast<int>(swizz[i]) - static_cast<int>(SwizzleChannel::C_X) < 4 - offset % 4
                 spv::Id cond = b.createBinOp(spv::OpSLessThan, b.makeBoolType(), delta, first_base_threshold);
                 ops.push_back(b.createOp(spv::OpSelect, target_type, { cond, first_base, second_base }));
             }
@@ -956,7 +956,7 @@ spv::Id load(spv::Builder &b, const SpirvShaderParameters &params, SpirvUtilFunc
     if (op.bank == RegisterBank::IMMEDIATE || !get_reg_bank(params, op.bank)) {
         if (op.bank != RegisterBank::INDEXED1 && op.bank != RegisterBank::INDEXED2) {
             if (dest_comp_count == 1) {
-                if ((int)op.swizzle[0] >= (int)SwizzleChannel::C_0) {
+                if (static_cast<int>(op.swizzle[0]) >= static_cast<int>(SwizzleChannel::C_0)) {
                     return get_correspond_constant_with_channel(b, op.swizzle[0]);
                 }
             }
@@ -995,7 +995,7 @@ spv::Id load(spv::Builder &b, const SpirvShaderParameters &params, SpirvUtilFunc
         const Imm2 bank_enc = (op.num >> 5) & 0b11;
         const Imm5 add_off = (op.num & 0b11111) + shift_offset;
 
-        const std::int8_t idx_off = (int)op.bank - (int)RegisterBank::INDEXED1;
+        const std::int8_t idx_off = static_cast<int>(op.bank) - static_cast<int>(RegisterBank::INDEXED1);
 
         switch (bank_enc) {
         case 0: {
@@ -1293,7 +1293,7 @@ void store(spv::Builder &b, const SpirvShaderParameters &params, SpirvUtilFuncti
                     if (b.isScalar(source) || total_comp_source == 1) {
                         ops.push_back(source);
                     } else {
-                        ops.push_back(b.createOp(spv::OpVectorExtractDynamic, vec_comp_type, { source, b.makeIntConstant(std::min(source_value_taken_count++, (int)total_comp_source - 1)) }));
+                        ops.push_back(b.createOp(spv::OpVectorExtractDynamic, vec_comp_type, { source, b.makeIntConstant(std::min(source_value_taken_count++, static_cast<int>(total_comp_source) - 1)) }));
                     }
                 } else {
                     if (elem == spv::NoResult) {
@@ -1310,7 +1310,7 @@ void store(spv::Builder &b, const SpirvShaderParameters &params, SpirvUtilFuncti
                 }
             }
 
-            spv::Id result_type = utils::make_vector_or_scalar_type(b, vec_comp_type, (int)ops.size());
+            spv::Id result_type = utils::make_vector_or_scalar_type(b, vec_comp_type, static_cast<int>(ops.size()));
             spv::Id result = ops.size() == 1 ? ops[0] : b.createCompositeConstruct(result_type, ops);
             result = pack_one(b, utils, features, result, dest.type);
 
@@ -1337,7 +1337,7 @@ void store(spv::Builder &b, const SpirvShaderParameters &params, SpirvUtilFuncti
 
     // Now we do store!
     if (total_comp_source == 1) {
-        insert_offset += (int)(nearest_swizz_on / (4 / size_comp));
+        insert_offset += static_cast<int>(nearest_swizz_on / (4 / size_comp));
         elem = b.createOp(spv::OpAccessChain, comp_type, { bank_base, b.makeIntConstant(insert_offset >> 2) });
         spv::Id inserted = b.createOp(spv::OpVectorInsertDynamic, bank_base_elem_type, { b.createLoad(elem, spv::NoPrecision), source, b.makeIntConstant(insert_offset % 4) });
 
diff --git a/vita3k/util/include/util/arm.h b/vita3k/util/include/util/arm.h
index f52ae017eb..032c21e47b 100644
--- a/vita3k/util/include/util/arm.h
+++ b/vita3k/util/include/util/arm.h
@@ -28,4 +28,4 @@
 
 uint32_t encode_arm_inst(uint8_t type, uint32_t immed, uint16_t reg);
 // SVC not implemented for thumb
-uint32_t encode_thumb_inst(uint8_t type, uint32_t immed, uint16_t reg);
\ No newline at end of file
+uint32_t encode_thumb_inst(uint8_t type, uint32_t immed, uint16_t reg);
diff --git a/vita3k/util/include/util/float_to_half.h b/vita3k/util/include/util/float_to_half.h
index 2365d30254..869d6fff73 100644
--- a/vita3k/util/include/util/float_to_half.h
+++ b/vita3k/util/include/util/float_to_half.h
@@ -160,4 +160,4 @@ auto encode_flt16(F &&value) { return flt16_encoder::encode<true>(std::forward<F
 
 template <typename F = float, typename X>
 auto decode_flt16(X &&value) { return flt16_encoder::decode<F>(std::forward<X>(value)); }
-} // namespace util
\ No newline at end of file
+} // namespace util
diff --git a/vita3k/util/include/util/keywords.h b/vita3k/util/include/util/keywords.h
index 321db3b538..02c872bc21 100644
--- a/vita3k/util/include/util/keywords.h
+++ b/vita3k/util/include/util/keywords.h
@@ -19,4 +19,4 @@
 
 #if defined(_MSC_VER)
 #define __restrict__ __restrict
-#endif
\ No newline at end of file
+#endif
diff --git a/vita3k/util/src/net_utils.cpp b/vita3k/util/src/net_utils.cpp
index 029c602e49..fa65de23dc 100644
--- a/vita3k/util/src/net_utils.cpp
+++ b/vita3k/util/src/net_utils.cpp
@@ -341,7 +341,7 @@ std::string get_web_response(const std::string &url) {
 
     std::string response_string;
     const auto writeFunc = +[](void *ptr, size_t size, size_t nmemb, std::string *data) {
-        data->append((char *)ptr, size * nmemb);
+        data->append(static_cast<char *>(ptr), size * nmemb);
         return size * nmemb;
     };
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeFunc);