diff --git a/.gitignore b/.gitignore
index 5584e1a..b3536eb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -42,4 +42,5 @@ CMakeError.log
 .DS_Store
 assets/config.toml
 .venv/
-pyout/
\ No newline at end of file
+pyout/
+vcpkg_installed/
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 68c0ba4..0b9e45b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -69,6 +69,11 @@ target_compile_definitions(${PROJECT_NAME}
         ASIO_STANDALONE
         ASIO_NO_DEPRECATED
         $<$<CONFIG:Debug>:DEBUG_MODE>
+        $<$<CXX_COMPILER_ID:MSVC>:
+            WIN32_LEAN_AND_MEAN
+            NOMINMAX
+            _CRT_SECURE_NO_WARNINGS
+        >
 )
 
 if(CMAKE_CONFIGURATION_TYPES)
@@ -119,6 +124,7 @@ target_link_libraries(${PROJECT_NAME}
         absl::log
         absl::check
         zstd::zstd
+        $<$<PLATFORM_ID:Windows>:ws2_32>
 
 )
 
diff --git a/include/Cubed/gameplay/packet.hpp b/include/Cubed/gameplay/packet.hpp
index b13f995..a87fa17 100644
--- a/include/Cubed/gameplay/packet.hpp
+++ b/include/Cubed/gameplay/packet.hpp
@@ -6,7 +6,14 @@
 #include <cstdint>
 #include <cstring>
 #include <memory>
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <winsock2.h>
+#else
 #include <netinet/in.h>
+#endif
 #include <span>
 #include <stdexcept>
 #include <type_traits>
@@ -23,11 +30,10 @@ enum class CompressType : uint16_t {
 
 inline CompressType get_compress_type(uint16_t id) {
     using enum CompressType;
-    constexpr auto& to = std::to_underlying<CompressType>;
     switch (id) {
-    case to(NONE):
+    case std::to_underlying(NONE):
         return NONE;
-    case to(ZSTD):
+    case std::to_underlying(ZSTD):
         return ZSTD;
     }
     throw std::runtime_error(std::format("Unknown CompressType {}", id));
diff --git a/include/Cubed/tools/log.hpp b/include/Cubed/tools/log.hpp
index 783f68c..7a3d0a1 100644
--- a/include/Cubed/tools/log.hpp
+++ b/include/Cubed/tools/log.hpp
@@ -9,7 +9,7 @@
 namespace Cubed {
 
 namespace Logger {
-enum class Level { TRACE, DEBUG, INFO, ERROR, WARN };
+enum class Level { L_TRACE, L_DEBUG, L_INFO, L_ERROR, L_WARN };
 
 template <typename... Args>
 inline void info(std::format_string<Args...> fmt, Args&&... args) {
@@ -53,7 +53,7 @@ inline void log(Level level, std::source_location loc,
         std::chrono::system_clock::now());
     std::string msg = std::vformat(fmt.get(), std::make_format_args(args...));
     switch (level) {
-    case Logger::Level::TRACE:
+    case Logger::Level::L_TRACE:
         std::osyncstream(std::cout)
             << "\033[1;34m"
             << std::format("[TRACE][{:%Y-%m-%d %H:%M:%S}]", now_time) << "["
@@ -61,20 +61,20 @@ inline void log(Level level, std::source_location loc,
             << "[" << loc.function_name() << "]" << msg << "\033[0m"
             << "\n";
         break;
-    case Logger::Level::DEBUG:
+    case Logger::Level::L_DEBUG:
         std::osyncstream(std::cout)
             << "\033[1;34m"
             << std::format("[DEBUG][{:%Y-%m-%d %H:%M:%S}]", now_time) << msg
             << "\033[0m"
             << "\n";
         break;
-    case Logger::Level::INFO:
+    case Logger::Level::L_INFO:
         info(fmt, std::forward<Args>(args)...);
         break;
-    case Logger::Level::WARN:
+    case Logger::Level::L_WARN:
         warn(fmt, std::forward<Args>(args)...);
         break;
-    case Logger::Level::ERROR:
+    case Logger::Level::L_ERROR:
         error(fmt, std::forward<Args>(args)...);
         break;
     }
diff --git a/src/app.cpp b/src/app.cpp
index 61e97c6..c12fd25 100644
--- a/src/app.cpp
+++ b/src/app.cpp
@@ -96,10 +96,10 @@ void App::handle_argument(int argc, char** argv) {
              [&](ArgParser& p) {
                  auto arg = p.require_next("-p");
 
-                 auto r =
-                     std::from_chars(arg.begin(), arg.end(), m_argument.port);
+                 auto r = std::from_chars(arg.data(), arg.data() + arg.size(),
+                                          m_argument.port);
 
-                 if (r.ec != std::errc{} || r.ptr != arg.end()) {
+                 if (r.ec != std::errc{} || arg.data() + arg.size()) {
                      throw std::runtime_error(
                          std::format("Invalid port: {}", arg));
                  }
diff --git a/src/gameplay/client_world.cpp b/src/gameplay/client_world.cpp
index 65143e8..d396ee9 100644
--- a/src/gameplay/client_world.cpp
+++ b/src/gameplay/client_world.cpp
@@ -3,6 +3,9 @@
 #include "Cubed/config.hpp"
 #include "Cubed/gameplay/game_time.hpp"
 #include "Cubed/gameplay/packet.hpp"
+
+#include <numbers>
+
 using namespace std::chrono;
 using namespace std::chrono_literals;
 using namespace google::protobuf;
diff --git a/src/gameplay/network_client.cpp b/src/gameplay/network_client.cpp
index 08772b6..4217840 100644
--- a/src/gameplay/network_client.cpp
+++ b/src/gameplay/network_client.cpp
@@ -2,6 +2,9 @@
 
 #include "Cubed/gameplay/client_world.hpp"
 #include "Cubed/tools/log.hpp"
+
+#include <utility>
+
 using namespace google::protobuf;
 namespace Cubed {
 NetworkClient::NetworkClient(ClientWorld& world)
@@ -62,10 +65,10 @@ asio::awaitable<void> NetworkClient::read_loop() {
                                           asio::use_awaitable);
             }
 
-            constexpr auto& to_num = std::to_underlying<PacketEnum>;
+            using std::to_underlying;
             Arena arena;
             switch (header.cmd) {
-            case to_num(PacketEnum::LOGIN_RSP): {
+            case std::to_underlying(PacketEnum::LOGIN_RSP): {
                 auto* rsp = Arena::Create<LoginRsp>(&arena);
                 Logger::info("Client: Receive Login rsp");
                 if (decode_packet(*rsp, body_data, header)) {
@@ -76,7 +79,7 @@ asio::awaitable<void> NetworkClient::read_loop() {
                     }
                 }
             } break;
-            case to_num(PacketEnum::CHUNK_DATA_RSP): {
+            case std::to_underlying(PacketEnum::CHUNK_DATA_RSP): {
                 ChunkDataRsp rsp;
                 // Logger::info("Client: Receive Chunk Data rsp, size {}mb",
                 //              body_data.size() / 1024.0f / 1024);
@@ -84,32 +87,32 @@ asio::awaitable<void> NetworkClient::read_loop() {
                     m_world.receive_chunk(std::move(rsp));
                 }
             } break;
-            case to_num(PacketEnum::BLOCK_CHANGE_RSP): {
+            case std::to_underlying(PacketEnum::BLOCK_CHANGE_RSP): {
                 auto* rsp = Arena::Create<BlockChangeRsp>(&arena);
                 Logger::info("Client: Receive Block Change rsp");
                 if (decode_packet(*rsp, body_data, header)) {
                     m_world.receive_block_change(*rsp);
                 }
             } break;
-            case to_num(PacketEnum::UPDATE_TIME): {
+            case std::to_underlying(PacketEnum::UPDATE_TIME): {
                 auto* rsp = Arena::Create<UpdateTime>(&arena);
                 if (decode_packet(*rsp, body_data, header)) {
                     m_world.receive_time(*rsp);
                 }
             } break;
-            case to_num(PacketEnum::PLAYER_INFO_RSP): {
+            case std::to_underlying(PacketEnum::PLAYER_INFO_RSP): {
                 auto* rsp = Arena::Create<PlayerInfoRsp>(&arena);
                 if (decode_packet(*rsp, body_data, header)) {
                     m_world.receive_remote_player(*rsp);
                 }
             } break;
-            case to_num(PacketEnum::LOGOUT_RSP): {
+            case std::to_underlying(PacketEnum::LOGOUT_RSP): {
                 auto* rsp = Arena::Create<LogoutRsp>(&arena);
                 if (decode_packet(*rsp, body_data, header)) {
                     m_world.receive_player_logout(*rsp);
                 }
             } break;
-            case to_num(PacketEnum::S2C_CLEAR_ALL_CHUNKS): {
+            case std::to_underlying(PacketEnum::S2C_CLEAR_ALL_CHUNKS): {
                 auto* rsp = Arena::Create<S2C_ClearAllChunks>(&arena);
                 if (decode_packet(*rsp, body_data, header)) {
                     if (rsp->clear()) {
diff --git a/src/gameplay/session.cpp b/src/gameplay/session.cpp
index be9a043..29dc146 100644
--- a/src/gameplay/session.cpp
+++ b/src/gameplay/session.cpp
@@ -53,10 +53,9 @@ asio::awaitable<void> Session::read_loop() {
                 co_await asio::async_read(m_socket, asio::buffer(body_data),
                                           asio::use_awaitable);
             }
-            constexpr auto& to_num = std::to_underlying<PacketEnum>;
             auto cmd_id = header.cmd;
             Arena arena;
-            if (cmd_id == to_num(PacketEnum::LOGIN_REQ)) {
+            if (cmd_id == std::to_underlying(PacketEnum::LOGIN_REQ)) {
                 auto* req = Arena::Create<LoginReq>(&arena);
                 Logger::info("Session: Receive Login req");
                 if (decode_packet(*req, body_data, header)) {
@@ -64,7 +63,7 @@ asio::awaitable<void> Session::read_loop() {
                                                        shared_from_this());
                 }
             }
-            if (cmd_id == to_num(PacketEnum::PLAYER_POS)) {
+            if (cmd_id == std::to_underlying(PacketEnum::PLAYER_POS)) {
                 auto* pos = Arena::Create<PlayerPos>(&arena);
                 if (decode_packet(*pos, body_data, header)) {
                     m_server_world.sync_player_pos(pos->uuid(), pos->pos().x(),
@@ -72,7 +71,7 @@ asio::awaitable<void> Session::read_loop() {
                                                    pos->pos().z());
                 }
             }
-            if (cmd_id == to_num(PacketEnum::CHUNK_DATA_REQ)) {
+            if (cmd_id == std::to_underlying(PacketEnum::CHUNK_DATA_REQ)) {
                 auto* req = Arena::Create<ChunkDataReq>(&arena);
                 // Logger::info("Session: Receive Chunk Data req");
                 if (decode_packet(*req, body_data, header)) {
@@ -81,14 +80,14 @@ asio::awaitable<void> Session::read_loop() {
                         ChunkPos(req->pos().x(), req->pos().z()));
                 }
             }
-            if (cmd_id == to_num(PacketEnum::BLOCK_CHANGE_REQ)) {
+            if (cmd_id == std::to_underlying(PacketEnum::BLOCK_CHANGE_REQ)) {
                 auto* req = Arena::Create<BlockChangeReq>(&arena);
                 Logger::info("Session: Receive Block Change req");
                 if (decode_packet(*req, body_data, header)) {
                     m_server_world.handle_block_change(*req);
                 }
             }
-            if (cmd_id == to_num(PacketEnum::LOGOUT_REQ)) {
+            if (cmd_id == std::to_underlying(PacketEnum::LOGOUT_REQ)) {
                 auto* req = Arena::Create<LogoutReq>(&arena);
                 if (decode_packet(*req, body_data, header)) {
                     m_server_world.handle_player_exit(req->uuid());
diff --git a/vcpkg.json b/vcpkg.json
new file mode 100644
index 0000000..629fd6a
--- /dev/null
+++ b/vcpkg.json
@@ -0,0 +1,7 @@
+{
+  "dependencies": [
+    "protobuf",
+    "zstd"
+  ],
+  "builtin-baseline": "a0400024711b283056538ac19ced80b91a83c24c"
+}