diff --git a/ntcore/src/main/native/cpp/net/WebSocketConnection.cpp b/ntcore/src/main/native/cpp/net/WebSocketConnection.cpp
index 2547c4f514..b023d7f6df 100644
--- a/ntcore/src/main/native/cpp/net/WebSocketConnection.cpp
+++ b/ntcore/src/main/native/cpp/net/WebSocketConnection.cpp
@@ -60,8 +60,8 @@ void WebSocketConnection::Stream::write_impl(const char* data, size_t len) {
     m_conn.m_written += amt;
     if (!m_disableAlloc) {
 #ifdef NT_ENABLE_WS_FRAG
-      m_conn.m_frames.back().opcode &= ~wpi::net::WebSocket::kFlagFin;
-      m_conn.StartFrame(wpi::net::WebSocket::Frame::kFragment);
+      m_conn.m_frames.back().opcode &= ~wpi::net::WebSocket::FLAG_FIN;
+      m_conn.StartFrame(wpi::net::WebSocket::Frame::FRAGMENT);
 #else
       m_conn.m_bufs.emplace_back(m_conn.AllocBuf());
       m_conn.m_bufs.back().len = 0;
@@ -90,8 +90,8 @@ void WebSocketConnection::Stream::write_impl(const char* data, size_t len) {
     if (buf.len >= kAllocSize && (len > 0 || !m_disableAlloc)) {
 #ifdef NT_ENABLE_WS_FRAG
       // fragment the current frame and start a new one
-      m_conn.m_frames.back().opcode &= ~wpi::net::WebSocket::kFlagFin;
-      m_conn.StartFrame(wpi::net::WebSocket::Frame::kFragment);
+      m_conn.m_frames.back().opcode &= ~wpi::net::WebSocket::FLAG_FIN;
+      m_conn.StartFrame(wpi::net::WebSocket::Frame::FRAGMENT);
 #else
       m_conn.m_bufs.emplace_back(m_conn.AllocBuf());
       m_conn.m_bufs.back().len = 0;
@@ -165,10 +165,10 @@ int WebSocketConnection::Write(
     }
     m_state = kind;
     if (!m_frames.empty()) {
-      m_frames.back().opcode |= wpi::net::WebSocket::kFlagFin;
+      m_frames.back().opcode |= wpi::net::WebSocket::FLAG_FIN;
     }
-    StartFrame(m_state == kText ? wpi::net::WebSocket::Frame::kText
-                                : wpi::net::WebSocket::Frame::kBinary);
+    StartFrame(m_state == kText ? wpi::net::WebSocket::Frame::TEXT
+                                : wpi::net::WebSocket::Frame::BINARY);
     m_framePos = 0;
     first = true;
   }
@@ -203,7 +203,7 @@ int WebSocketConnection::Flush() {
   if (m_frames.empty()) {
     return 0;
   }
-  m_frames.back().opcode |= wpi::net::WebSocket::kFlagFin;
+  m_frames.back().opcode |= wpi::net::WebSocket::FLAG_FIN;
 
   // convert internal frames into WS frames
   m_ws_frames.clear();
@@ -249,11 +249,11 @@ void WebSocketConnection::Send(
     wpi::util::function_ref<void(wpi::util::raw_ostream& os)> writer) {
   wpi::util::SmallVector<wpi::net::uv::Buffer, 4> bufs;
   wpi::net::raw_uv_ostream os{bufs, [this] { return AllocBuf(); }};
-  if (opcode == wpi::net::WebSocket::Frame::kText) {
+  if (opcode == wpi::net::WebSocket::Frame::TEXT) {
     os << '[';
   }
   writer(os);
-  if (opcode == wpi::net::WebSocket::Frame::kText) {
+  if (opcode == wpi::net::WebSocket::Frame::TEXT) {
     os << ']';
   }
   wpi::net::WebSocket::Frame frame{opcode, os.bufs()};
diff --git a/ntcore/src/main/native/cpp/net/WebSocketConnection.hpp b/ntcore/src/main/native/cpp/net/WebSocketConnection.hpp
index 52a966db8f..8dd25dc4f8 100644
--- a/ntcore/src/main/native/cpp/net/WebSocketConnection.hpp
+++ b/ntcore/src/main/native/cpp/net/WebSocketConnection.hpp
@@ -49,11 +49,11 @@ class WebSocketConnection final
 
   void SendText(
       wpi::util::function_ref<void(wpi::util::raw_ostream& os)> writer) final {
-    Send(wpi::net::WebSocket::Frame::kText, writer);
+    Send(wpi::net::WebSocket::Frame::TEXT, writer);
   }
   void SendBinary(
       wpi::util::function_ref<void(wpi::util::raw_ostream& os)> writer) final {
-    Send(wpi::net::WebSocket::Frame::kBinary, writer);
+    Send(wpi::net::WebSocket::Frame::BINARY, writer);
   }
 
   uint64_t GetLastFlushTime() const final { return m_lastFlushTime; }
diff --git a/wpinet/src/main/native/cpp/DsClient.cpp b/wpinet/src/main/native/cpp/DsClient.cpp
index 8c44ae0bf8..3b81175ae9 100644
--- a/wpinet/src/main/native/cpp/DsClient.cpp
+++ b/wpinet/src/main/native/cpp/DsClient.cpp
@@ -16,7 +16,7 @@
 
 using namespace wpi::net;
 
-static constexpr uv::Timer::Time kReconnectTime{500};
+static constexpr uv::Timer::Time RECONNECT_TIME{500};
 
 DsClient::DsClient(wpi::net::uv::Loop& loop, wpi::util::Logger& logger,
                    const private_init&)
@@ -30,7 +30,7 @@ DsClient::DsClient(wpi::net::uv::Loop& loop, wpi::util::Logger& logger,
     WPI_DEBUG4(m_logger, "DS connection closed");
     clearIp();
     // try to connect again
-    m_tcp->Reuse([this] { m_timer->Start(kReconnectTime); });
+    m_tcp->Reuse([this] { m_timer->Start(RECONNECT_TIME); });
   });
   m_tcp->data.connect([this](wpi::net::uv::Buffer buf, size_t len) {
     HandleIncoming({buf.base, len});
@@ -58,7 +58,7 @@ void DsClient::Connect() {
   connreq->error = [this](uv::Error err) {
     WPI_DEBUG4(m_logger, "DS connect failure: {}", err.str());
     // try to connect again
-    m_tcp->Reuse([this] { m_timer->Start(kReconnectTime); });
+    m_tcp->Reuse([this] { m_timer->Start(RECONNECT_TIME); });
   };
 
   WPI_DEBUG4(m_logger, "Starting DS connection attempt");
diff --git a/wpinet/src/main/native/cpp/HttpParser.cpp b/wpinet/src/main/native/cpp/HttpParser.cpp
index 056c5979f1..8c0e89e95f 100644
--- a/wpinet/src/main/native/cpp/HttpParser.cpp
+++ b/wpinet/src/main/native/cpp/HttpParser.cpp
@@ -25,7 +25,7 @@ HttpParser::HttpParser(Type type) {
   m_settings.on_message_begin = [](http_parser* p) -> int {
     auto& self = *static_cast<HttpParser*>(p->data);
     self.m_urlBuf.clear();
-    self.m_state = kStart;
+    self.m_state = State::START;
     self.messageBegin();
     return self.m_aborted;
   };
@@ -38,7 +38,7 @@ HttpParser::HttpParser(Type type) {
       return 1;
     }
     self.m_urlBuf += std::string_view{at, length};
-    self.m_state = kUrl;
+    self.m_state = State::URL;
     return 0;
   };
 
@@ -51,7 +51,7 @@ HttpParser::HttpParser(Type type) {
       return 1;
     }
     self.m_valueBuf += std::string_view{at, length};
-    self.m_state = kStatus;
+    self.m_state = State::STATUS;
     return 0;
   };
 
@@ -61,7 +61,7 @@ HttpParser::HttpParser(Type type) {
     auto& self = *static_cast<HttpParser*>(p->data);
 
     // once we're in header, we know the URL is complete
-    if (self.m_state == kUrl) {
+    if (self.m_state == State::URL) {
       self.url(self.m_urlBuf);
       if (self.m_aborted) {
         return 1;
@@ -69,7 +69,7 @@ HttpParser::HttpParser(Type type) {
     }
 
     // once we're in header, we know the status is complete
-    if (self.m_state == kStatus) {
+    if (self.m_state == State::STATUS) {
       self.status(self.m_valueBuf);
       if (self.m_aborted) {
         return 1;
@@ -77,7 +77,7 @@ HttpParser::HttpParser(Type type) {
     }
 
     // if we previously were in value state, that means we finished a header
-    if (self.m_state == kValue) {
+    if (self.m_state == State::VALUE) {
       self.header(self.m_fieldBuf, self.m_valueBuf);
       if (self.m_aborted) {
         return 1;
@@ -85,8 +85,8 @@ HttpParser::HttpParser(Type type) {
     }
 
     // clear field and value when we enter this state
-    if (self.m_state != kField) {
-      self.m_state = kField;
+    if (self.m_state != State::FIELD) {
+      self.m_state = State::FIELD;
       self.m_fieldBuf.clear();
       self.m_valueBuf.clear();
     }
@@ -105,8 +105,8 @@ HttpParser::HttpParser(Type type) {
     auto& self = *static_cast<HttpParser*>(p->data);
 
     // if we weren't previously in value state, clear the buffer
-    if (self.m_state != kValue) {
-      self.m_state = kValue;
+    if (self.m_state != State::VALUE) {
+      self.m_state = State::VALUE;
       self.m_valueBuf.clear();
     }
 
@@ -123,7 +123,7 @@ HttpParser::HttpParser(Type type) {
     auto& self = *static_cast<HttpParser*>(p->data);
 
     // if we previously were in url state, that means we finished the url
-    if (self.m_state == kUrl) {
+    if (self.m_state == State::URL) {
       self.url(self.m_urlBuf);
       if (self.m_aborted) {
         return 1;
@@ -131,7 +131,7 @@ HttpParser::HttpParser(Type type) {
     }
 
     // if we previously were in status state, that means we finished the status
-    if (self.m_state == kStatus) {
+    if (self.m_state == State::STATUS) {
       self.status(self.m_valueBuf);
       if (self.m_aborted) {
         return 1;
@@ -139,7 +139,7 @@ HttpParser::HttpParser(Type type) {
     }
 
     // if we previously were in value state, that means we finished a header
-    if (self.m_state == kValue) {
+    if (self.m_state == State::VALUE) {
       self.header(self.m_fieldBuf, self.m_valueBuf);
       if (self.m_aborted) {
         return 1;
@@ -185,7 +185,7 @@ void HttpParser::Reset(Type type) {
                    static_cast<http_parser_type>(static_cast<int>(type)));
   m_parser.data = this;
   m_maxLength = 1024;
-  m_state = kStart;
+  m_state = State::START;
   m_urlBuf.clear();
   m_fieldBuf.clear();
   m_valueBuf.clear();
diff --git a/wpinet/src/main/native/cpp/HttpUtil.cpp b/wpinet/src/main/native/cpp/HttpUtil.cpp
index cc2308dc96..1677382035 100644
--- a/wpinet/src/main/native/cpp/HttpUtil.cpp
+++ b/wpinet/src/main/native/cpp/HttpUtil.cpp
@@ -433,19 +433,19 @@ void HttpMultipartScanner::SetBoundary(std::string_view boundary) {
   m_boundaryWith += boundary;
   m_boundaryWithout = "\n";
   m_boundaryWithout += boundary;
-  m_dashes = kUnknown;
+  m_dashes = Dashes::UNKNOWN;
 }
 
 void HttpMultipartScanner::Reset(bool saveSkipped) {
   m_saveSkipped = saveSkipped;
-  m_state = kBoundary;
+  m_state = State::BOUNDARY;
   m_posWith = 0;
   m_posWithout = 0;
   m_buf.resize(0);
 }
 
 std::string_view HttpMultipartScanner::Execute(std::string_view in) {
-  if (m_state == kDone) {
+  if (m_state == State::DONE) {
     Reset(m_saveSkipped);
   }
   if (m_saveSkipped) {
@@ -453,16 +453,16 @@ std::string_view HttpMultipartScanner::Execute(std::string_view in) {
   }
 
   size_t pos = 0;
-  if (m_state == kBoundary) {
+  if (m_state == State::BOUNDARY) {
     for (char ch : in) {
       ++pos;
-      if (m_dashes != kWithout) {
+      if (m_dashes != Dashes::WITHOUT) {
         if (ch == m_boundaryWith[m_posWith]) {
           ++m_posWith;
           if (m_posWith == m_boundaryWith.size()) {
             // Found the boundary; transition to padding
-            m_state = kPadding;
-            m_dashes = kWith;  // no longer accept plain 'boundary'
+            m_state = State::PADDING;
+            m_dashes = Dashes::WITH;  // no longer accept plain 'boundary'
             break;
           }
         } else if (ch == m_boundaryWith[0]) {
@@ -472,13 +472,13 @@ std::string_view HttpMultipartScanner::Execute(std::string_view in) {
         }
       }
 
-      if (m_dashes != kWith) {
+      if (m_dashes != Dashes::WITH) {
         if (ch == m_boundaryWithout[m_posWithout]) {
           ++m_posWithout;
           if (m_posWithout == m_boundaryWithout.size()) {
             // Found the boundary; transition to padding
-            m_state = kPadding;
-            m_dashes = kWithout;  // no longer accept '--boundary'
+            m_state = State::PADDING;
+            m_dashes = Dashes::WITHOUT;  // no longer accept '--boundary'
             break;
           }
         } else if (ch == m_boundaryWithout[0]) {
@@ -490,12 +490,12 @@ std::string_view HttpMultipartScanner::Execute(std::string_view in) {
     }
   }
 
-  if (m_state == kPadding) {
+  if (m_state == State::PADDING) {
     for (char ch : wpi::util::drop_front(in, pos)) {
       ++pos;
       if (ch == '\n') {
         // Found the LF; return remaining input buffer (following it)
-        m_state = kDone;
+        m_state = State::DONE;
         if (m_saveSkipped) {
           m_buf.resize(m_buf.size() - in.size() + pos);
         }
diff --git a/wpinet/src/main/native/cpp/WebSocket.cpp b/wpinet/src/main/native/cpp/WebSocket.cpp
index 8c7cf93e8a..a233197eb7 100644
--- a/wpinet/src/main/native/cpp/WebSocket.cpp
+++ b/wpinet/src/main/native/cpp/WebSocket.cpp
@@ -107,9 +107,9 @@ class WebSocket::WriteReq : public uv::WriteReq,
   std::shared_ptr<WriteReq> m_controlCont;
 };
 
-static constexpr uint8_t kFlagMasking = 0x80;
-static constexpr uint8_t kLenMask = 0x7f;
-static constexpr size_t kWriteAllocSize = 4096;
+static constexpr uint8_t FLAG_MASKING = 0x80;
+static constexpr uint8_t LEN_MASK = 0x7f;
+static constexpr size_t WRITE_ALLOC_SIZE = 4096;
 
 class WebSocket::ClientHandshakeData {
  public:
@@ -134,7 +134,7 @@ class WebSocket::ClientHandshakeData {
 
   wpi::util::SmallString<64> key;  // the key sent to the server
   wpi::util::SmallVector<std::string, 2> protocols;  // valid protocols
-  HttpParser parser{HttpParser::kResponse};          // server response parser
+  HttpParser parser{HttpParser::Type::RESPONSE};     // server response parser
   bool hasUpgrade = false;
   bool hasConnection = false;
   bool hasAccept = false;
@@ -192,13 +192,13 @@ std::shared_ptr<WebSocket> WebSocket::CreateServer(uv::Stream& stream,
 
 void WebSocket::Close(uint16_t code, std::string_view reason) {
   SendClose(code, reason);
-  if (m_state != FAILED && m_state != CLOSED) {
-    m_state = CLOSING;
+  if (m_state != State::FAILED && m_state != State::CLOSED) {
+    m_state = State::CLOSING;
   }
 }
 
 void WebSocket::Fail(uint16_t code, std::string_view reason) {
-  if (m_state == FAILED || m_state == CLOSED) {
+  if (m_state == State::FAILED || m_state == State::CLOSED) {
     return;
   }
   SendClose(code, reason);
@@ -207,7 +207,7 @@ void WebSocket::Fail(uint16_t code, std::string_view reason) {
 }
 
 void WebSocket::Terminate(uint16_t code, std::string_view reason) {
-  if (m_state == FAILED || m_state == CLOSED) {
+  if (m_state == State::FAILED || m_state == State::CLOSED) {
     return;
   }
   SetClosed(code, reason);
@@ -222,7 +222,7 @@ void WebSocket::StartClient(std::string_view uri, std::string_view host,
 
   // Build client request
   wpi::util::SmallVector<uv::Buffer, 4> bufs;
-  raw_uv_ostream os{bufs, kWriteAllocSize};
+  raw_uv_ostream os{bufs, WRITE_ALLOC_SIZE};
 
   os << "GET " << uri << " HTTP/1.1\r\n";
   os << "Host: " << host << "\r\n";
@@ -319,8 +319,8 @@ void WebSocket::StartClient(std::string_view uri, std::string_view host,
          !m_clientHandshake->protocols.empty())) {
       return Terminate(1002, "invalid response");
     }
-    if (m_state == CONNECTING) {
-      m_state = OPEN;
+    if (m_state == State::CONNECTING) {
+      m_state = State::OPEN;
       open(m_protocol);
     }
   });
@@ -342,7 +342,7 @@ void WebSocket::StartServer(std::string_view key, std::string_view version,
 
   // Build server response
   wpi::util::SmallVector<uv::Buffer, 4> bufs;
-  raw_uv_ostream os{bufs, kWriteAllocSize};
+  raw_uv_ostream os{bufs, WRITE_ALLOC_SIZE};
 
   // Handle unsupported version
   if (version != "13") {
@@ -380,8 +380,8 @@ void WebSocket::StartServer(std::string_view key, std::string_view version,
     for (auto& buf : bufs) {
       buf.Deallocate();
     }
-    if (m_state == CONNECTING) {
-      m_state = OPEN;
+    if (m_state == State::CONNECTING) {
+      m_state = State::OPEN;
       open(m_protocol);
     }
   });
@@ -390,13 +390,13 @@ void WebSocket::StartServer(std::string_view key, std::string_view version,
 void WebSocket::SendClose(uint16_t code, std::string_view reason) {
   wpi::util::SmallVector<uv::Buffer, 4> bufs;
   if (code != 1005) {
-    raw_uv_ostream os{bufs, kWriteAllocSize};
+    raw_uv_ostream os{bufs, WRITE_ALLOC_SIZE};
     const uint8_t codeMsb[] = {static_cast<uint8_t>((code >> 8) & 0xff),
                                static_cast<uint8_t>(code & 0xff)};
     os << std::span{codeMsb};
     os << reason;
   }
-  SendControl(kFlagFin | kOpClose, bufs, [](auto bufs, uv::Error) {
+  SendControl(FLAG_FIN | OP_CLOSE, bufs, [](auto bufs, uv::Error) {
     for (auto&& buf : bufs) {
       buf.Deallocate();
     }
@@ -404,10 +404,10 @@ void WebSocket::SendClose(uint16_t code, std::string_view reason) {
 }
 
 void WebSocket::SetClosed(uint16_t code, std::string_view reason, bool failed) {
-  if (m_state == FAILED || m_state == CLOSED) {
+  if (m_state == State::FAILED || m_state == State::CLOSED) {
     return;
   }
-  m_state = failed ? FAILED : CLOSED;
+  m_state = failed ? State::FAILED : State::CLOSED;
   closed(code, reason);
 }
 
@@ -430,21 +430,21 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
   m_lastReceivedTime = m_stream.GetLoopRef().Now().count();
 
   // ignore incoming data if we're failed or closed
-  if (m_state == FAILED || m_state == CLOSED) {
+  if (m_state == State::FAILED || m_state == State::CLOSED) {
     return;
   }
 
   std::string_view data{buf.base, size};
 
   // Handle connecting state (mainly on client)
-  if (m_state == CONNECTING) {
+  if (m_state == State::CONNECTING) {
     if (m_clientHandshake) {
       data = m_clientHandshake->parser.Execute(data);
       // check for parser failure
       if (m_clientHandshake->parser.HasError()) {
         return Terminate(1003, "invalid response");
       }
-      if (m_state != OPEN) {
+      if (m_state != State::OPEN) {
         return;  // not done with handshake yet
       }
 
@@ -478,13 +478,13 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
       // Once we have first two bytes, we can calculate the header size
       if (m_headerSize == 0) {
         m_headerSize = 2;
-        uint8_t len = m_header[1] & kLenMask;
+        uint8_t len = m_header[1] & LEN_MASK;
         if (len == 126) {
           m_headerSize += 2;
         } else if (len == 127) {
           m_headerSize += 8;
         }
-        bool masking = (m_header[1] & kFlagMasking) != 0;
+        bool masking = (m_header[1] & FLAG_MASKING) != 0;
         if (masking) {
           m_headerSize += 4;  // masking key
         }
@@ -510,7 +510,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
 
       if (m_header.size() >= m_headerSize) {
         // get payload length
-        uint8_t len = m_header[1] & kLenMask;
+        uint8_t len = m_header[1] & LEN_MASK;
         if (len == 126) {
           m_frameSize = (static_cast<uint16_t>(m_header[2]) << 8) |
                         static_cast<uint16_t>(m_header[3]);
@@ -528,7 +528,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
         }
 
         // limit maximum size
-        bool control = (m_header[0] & kFlagControl) != 0;
+        bool control = (m_header[0] & FLAG_CONTROL) != 0;
         if (((control ? m_controlPayload.size() : m_payload.size()) +
              m_frameSize) > m_maxMessageSize) {
           return Fail(1009, "message too large");
@@ -537,7 +537,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
     }
 
     if (m_frameSize != UINT64_MAX) {
-      bool control = (m_header[0] & kFlagControl) != 0;
+      bool control = (m_header[0] & FLAG_CONTROL) != 0;
       size_t need;
       if (control) {
         need = m_frameSize - m_controlPayload.size();
@@ -555,21 +555,21 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
       if (need == 0) {
         // We have a complete frame
         // If the message had masking, unmask it
-        if ((m_header[1] & kFlagMasking) != 0) {
+        if ((m_header[1] & FLAG_MASKING) != 0) {
           Unmask(control ? std::span{m_controlPayload}
                          : std::span{m_payload}.subspan(m_frameStart),
                  std::span<const uint8_t, 4>{&m_header[m_headerSize - 4], 4});
         }
 
         // Handle message
-        bool fin = (m_header[0] & kFlagFin) != 0;
-        uint8_t opcode = m_header[0] & kOpMask;
+        bool fin = (m_header[0] & FLAG_FIN) != 0;
+        uint8_t opcode = m_header[0] & OP_MASK;
         switch (opcode) {
-          case kOpCont:
+          case OP_CONT:
             WS_DEBUG(m_stream, "WS Fragment {} [{}]", m_payload.size(),
                      DebugBinary(m_payload));
             switch (m_fragmentOpcode) {
-              case kOpText:
+              case OP_TEXT:
                 if (!m_combineFragments || fin) {
                   std::string_view content{
                       reinterpret_cast<char*>(m_payload.data()),
@@ -579,7 +579,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
                   text(content, fin);
                 }
                 break;
-              case kOpBinary:
+              case OP_BINARY:
                 if (!m_combineFragments || fin) {
                   WS_DEBUG(m_stream, "WS RecvBinary(Defrag) {} ({})",
                            m_payload.size(), DebugBinary(m_payload));
@@ -594,7 +594,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
               m_fragmentOpcode = 0;
             }
             break;
-          case kOpText: {
+          case OP_TEXT: {
             std::string_view content{reinterpret_cast<char*>(m_payload.data()),
                                      m_payload.size()};
             if (m_fragmentOpcode != 0) {
@@ -613,7 +613,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
             }
             break;
           }
-          case kOpBinary:
+          case OP_BINARY:
             if (m_fragmentOpcode != 0) {
               WS_DEBUG(m_stream, "WS RecvBinary {} ({}) -> INCOMPLETE FRAGMENT",
                        m_payload.size(), DebugBinary(m_payload));
@@ -630,7 +630,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
               m_fragmentOpcode = opcode;
             }
             break;
-          case kOpClose: {
+          case OP_CLOSE: {
             uint16_t code;
             std::string_view reason;
             if (!fin) {
@@ -647,7 +647,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
                   2);
             }
             // Echo the close if we didn't previously send it
-            if (m_state != CLOSING) {
+            if (m_state != State::CLOSING) {
               SendClose(code, reason);
             }
             SetClosed(code, fmt::format("remote close: {}", reason));
@@ -657,15 +657,15 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
             }
             break;
           }
-          case kOpPing:
+          case OP_PING:
             if (!fin) {
               return Fail(1002, "cannot fragment control frames");
             }
             // If the connection is open, send a Pong in response
-            if (m_state == OPEN) {
+            if (m_state == State::OPEN) {
               wpi::util::SmallVector<uv::Buffer, 4> bufs;
               {
-                raw_uv_ostream os{bufs, kWriteAllocSize};
+                raw_uv_ostream os{bufs, WRITE_ALLOC_SIZE};
                 os << m_controlPayload;
               }
               SendPong(bufs, [](auto bufs, uv::Error) {
@@ -678,7 +678,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
                      DebugBinary(m_controlPayload));
             ping(m_controlPayload);
             break;
-          case kOpPong:
+          case OP_PONG:
             if (!fin) {
               return Fail(1002, "cannot fragment control frames");
             }
@@ -749,7 +749,7 @@ void WebSocket::SendFrames(
     std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
   // If we're not open, emit an error and don't send the data
   WS_DEBUG(m_stream, "SendFrames({})", frames.size());
-  if (m_state != OPEN) {
+  if (m_state != State::OPEN) {
     SendError(frames, callback);
     return;
   }
@@ -787,7 +787,7 @@ std::span<const WebSocket::Frame> WebSocket::TrySendFrames(
     std::span<const Frame> frames,
     std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
   // If we're not open, emit an error and don't send the data
-  if (m_state != WebSocket::OPEN) {
+  if (m_state != WebSocket::State::OPEN) {
     SendError(frames, callback);
     return {};
   }
@@ -814,7 +814,7 @@ void WebSocket::SendControl(
     std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
   Frame frame{opcode, data};
   // If we're not open, emit an error and don't send the data
-  if (m_state != WebSocket::OPEN) {
+  if (m_state != WebSocket::State::OPEN) {
     SendError({{frame}}, callback);
     return;
   }
@@ -851,7 +851,7 @@ void WebSocket::SendError(
     std::span<const Frame> frames,
     const std::function<void(std::span<uv::Buffer>, uv::Error)>& callback) {
   int err;
-  if (m_state == WebSocket::CONNECTING) {
+  if (m_state == WebSocket::State::CONNECTING) {
     err = UV_EAGAIN;
   } else {
     err = UV_ESHUTDOWN;
diff --git a/wpinet/src/main/native/cpp/WebSocketSerializer.cpp b/wpinet/src/main/native/cpp/WebSocketSerializer.cpp
index 0a79af4f36..7c6b6b5848 100644
--- a/wpinet/src/main/native/cpp/WebSocketSerializer.cpp
+++ b/wpinet/src/main/native/cpp/WebSocketSerializer.cpp
@@ -8,8 +8,8 @@
 
 using namespace wpi::net::detail;
 
-static constexpr uint8_t kFlagMasking = 0x80;
-static constexpr size_t kWriteAllocSize = 4096;
+static constexpr uint8_t FLAG_MASKING = 0x80;
+static constexpr size_t WRITE_ALLOC_SIZE = 4096;
 
 static std::span<uint8_t> BuildHeader(std::span<uint8_t, 10> header,
                                       bool server,
@@ -25,13 +25,13 @@ static std::span<uint8_t> BuildHeader(std::span<uint8_t, 10> header,
     size += buf.len;
   }
   if (size < 126) {
-    *pHeader++ = (server ? 0x00 : kFlagMasking) | size;
+    *pHeader++ = (server ? 0x00 : FLAG_MASKING) | size;
   } else if (size <= 0xffff) {
-    *pHeader++ = (server ? 0x00 : kFlagMasking) | 126;
+    *pHeader++ = (server ? 0x00 : FLAG_MASKING) | 126;
     *pHeader++ = (size >> 8) & 0xff;
     *pHeader++ = size & 0xff;
   } else {
-    *pHeader++ = (server ? 0x00 : kFlagMasking) | 127;
+    *pHeader++ = (server ? 0x00 : FLAG_MASKING) | 127;
     *pHeader++ = (size >> 56) & 0xff;
     *pHeader++ = (size >> 48) & 0xff;
     *pHeader++ = (size >> 40) & 0xff;
@@ -90,8 +90,8 @@ size_t SerializedFrames::AddServerFrame(const WebSocket::Frame& frame) {
 
   // manage allocBufs to efficiently store header
   if (m_allocBufs.empty() ||
-      (m_allocBufPos + header.size()) > kWriteAllocSize) {
-    m_allocBufs.emplace_back(uv::Buffer::Allocate(kWriteAllocSize));
+      (m_allocBufPos + header.size()) > WRITE_ALLOC_SIZE) {
+    m_allocBufs.emplace_back(uv::Buffer::Allocate(WRITE_ALLOC_SIZE));
     m_allocBufPos = 0;
   }
   char* internalBuf = m_allocBufs.back().data().data() + m_allocBufPos;
diff --git a/wpinet/src/main/native/cpp/WebSocketSerializer.hpp b/wpinet/src/main/native/cpp/WebSocketSerializer.hpp
index a6666d6046..846e856d54 100644
--- a/wpinet/src/main/native/cpp/WebSocketSerializer.hpp
+++ b/wpinet/src/main/native/cpp/WebSocketSerializer.hpp
@@ -204,7 +204,7 @@ std::span<const WebSocket::Frame> TrySendFrames(
         ++frameStart;
       }
 
-      bool isFin = (frameStart->opcode & WebSocket::kFlagFin) != 0;
+      bool isFin = (frameStart->opcode & WebSocket::FLAG_FIN) != 0;
       if (offIt != offEnd && *offIt == sentBytes && isFin) {
         // we finished at a normal FIN frame boundary; no need for a Write()
         ++frameStart;
@@ -271,7 +271,7 @@ std::span<const WebSocket::Frame> TrySendFrames(
           continuePos += req->m_frames.AddFrame(*frameStart, server);
         }
         req->m_continueFrameOffs.emplace_back(continuePos);
-        isFin = (frameStart->opcode & WebSocket::kFlagFin) != 0;
+        isFin = (frameStart->opcode & WebSocket::FLAG_FIN) != 0;
         ++frameStart;
       }
 
diff --git a/wpinet/src/main/native/cpp/uv/Process.cpp b/wpinet/src/main/native/cpp/uv/Process.cpp
index 26242a33d9..ebed960857 100644
--- a/wpinet/src/main/native/cpp/uv/Process.cpp
+++ b/wpinet/src/main/native/cpp/uv/Process.cpp
@@ -45,30 +45,30 @@ std::shared_ptr<Process> Process::SpawnArray(Loop& loop, std::string_view file,
 
   for (auto&& o : options) {
     switch (o.m_type) {
-      case Option::kArg:
+      case Option::Type::ARG:
         argsBuf.push_back(const_cast<char*>(o.m_data.str));
         break;
-      case Option::kEnv:
+      case Option::Type::ENV:
         envBuf.push_back(const_cast<char*>(o.m_data.str));
         break;
-      case Option::kCwd:
+      case Option::Type::WORKING_DIRECTORY:
         coptions.cwd = o.m_data.str[0] == '\0' ? nullptr : o.m_data.str;
         break;
-      case Option::kUid:
+      case Option::Type::USER_ID:
         coptions.uid = o.m_data.uid;
         coptions.flags |= UV_PROCESS_SETUID;
         break;
-      case Option::kGid:
+      case Option::Type::GROUP_ID:
         coptions.gid = o.m_data.gid;
         coptions.flags |= UV_PROCESS_SETGID;
         break;
-      case Option::kSetFlags:
+      case Option::Type::SET_FLAGS:
         coptions.flags |= o.m_data.flags;
         break;
-      case Option::kClearFlags:
+      case Option::Type::CLEAR_FLAGS:
         coptions.flags &= ~o.m_data.flags;
         break;
-      case Option::kStdioIgnore: {
+      case Option::Type::STDIO_IGNORE: {
         size_t index = o.m_data.stdio.index;
         if (index >= stdioBuf.size()) {
           stdioBuf.resize(index + 1);
@@ -77,7 +77,7 @@ std::shared_ptr<Process> Process::SpawnArray(Loop& loop, std::string_view file,
         stdioBuf[index].data.fd = 0;
         break;
       }
-      case Option::kStdioInheritFd: {
+      case Option::Type::STDIO_INHERIT_FD: {
         size_t index = o.m_data.stdio.index;
         if (index >= stdioBuf.size()) {
           stdioBuf.resize(index + 1);
@@ -86,7 +86,7 @@ std::shared_ptr<Process> Process::SpawnArray(Loop& loop, std::string_view file,
         stdioBuf[index].data.fd = o.m_data.stdio.fd;
         break;
       }
-      case Option::kStdioInheritPipe: {
+      case Option::Type::STDIO_INHERIT_PIPE: {
         size_t index = o.m_data.stdio.index;
         if (index >= stdioBuf.size()) {
           stdioBuf.resize(index + 1);
@@ -95,7 +95,7 @@ std::shared_ptr<Process> Process::SpawnArray(Loop& loop, std::string_view file,
         stdioBuf[index].data.stream = o.m_data.stdio.pipe->GetRawStream();
         break;
       }
-      case Option::kStdioCreatePipe: {
+      case Option::Type::STDIO_CREATE_PIPE: {
         size_t index = o.m_data.stdio.index;
         if (index >= stdioBuf.size()) {
           stdioBuf.resize(index + 1);
diff --git a/wpinet/src/main/native/include/wpi/net/HttpParser.hpp b/wpinet/src/main/native/include/wpi/net/HttpParser.hpp
index 28d6211de0..5cf99a639b 100644
--- a/wpinet/src/main/native/include/wpi/net/HttpParser.hpp
+++ b/wpinet/src/main/native/include/wpi/net/HttpParser.hpp
@@ -21,10 +21,10 @@ namespace wpi::net {
  */
 class HttpParser {
  public:
-  enum Type {
-    kRequest = HTTP_REQUEST,
-    kResponse = HTTP_RESPONSE,
-    kBoth = HTTP_BOTH
+  enum class Type {
+    REQUEST = HTTP_REQUEST,
+    RESPONSE = HTTP_RESPONSE,
+    BOTH = HTTP_BOTH
   };
 
   /**
@@ -213,7 +213,8 @@ class HttpParser {
   http_parser_settings m_settings;
 
   size_t m_maxLength = 1024;
-  enum { kStart, kUrl, kStatus, kField, kValue } m_state = kStart;
+  enum class State { START, URL, STATUS, FIELD, VALUE };
+  State m_state = State::START;
   wpi::util::SmallString<128> m_urlBuf;
   wpi::util::SmallString<32> m_fieldBuf;
   wpi::util::SmallString<128> m_valueBuf;
diff --git a/wpinet/src/main/native/include/wpi/net/HttpServerConnection.hpp b/wpinet/src/main/native/include/wpi/net/HttpServerConnection.hpp
index 47e07b6225..9a22a48e9b 100644
--- a/wpinet/src/main/native/include/wpi/net/HttpServerConnection.hpp
+++ b/wpinet/src/main/native/include/wpi/net/HttpServerConnection.hpp
@@ -128,7 +128,7 @@ class HttpServerConnection {
   virtual void SendError(int code, std::string_view message = {});
 
   /** The HTTP request. */
-  HttpParser m_request{HttpParser::kRequest};
+  HttpParser m_request{HttpParser::Type::REQUEST};
 
   /** Whether the connection should be kept alive. */
   bool m_keepAlive = false;
diff --git a/wpinet/src/main/native/include/wpi/net/HttpUtil.hpp b/wpinet/src/main/native/include/wpi/net/HttpUtil.hpp
index cd6fffc8a4..2b8fd285b2 100644
--- a/wpinet/src/main/native/include/wpi/net/HttpUtil.hpp
+++ b/wpinet/src/main/native/include/wpi/net/HttpUtil.hpp
@@ -432,7 +432,7 @@ class HttpMultipartScanner {
   std::string_view Execute(std::string_view in);
 
   // Returns true when the boundary has been found.
-  bool IsDone() const { return m_state == kDone; }
+  bool IsDone() const { return m_state == State::DONE; }
 
   // Get the skipped data.  Will be empty if saveSkipped was false.
   std::string_view GetSkipped() const {
@@ -443,10 +443,10 @@ class HttpMultipartScanner {
   wpi::util::SmallString<64> m_boundaryWith, m_boundaryWithout;
 
   // Internal state
-  enum State { kBoundary, kPadding, kDone };
+  enum class State { BOUNDARY, PADDING, DONE };
   State m_state;
   size_t m_posWith, m_posWithout;
-  enum Dashes { kUnknown, kWith, kWithout };
+  enum class Dashes { UNKNOWN, WITH, WITHOUT };
   Dashes m_dashes;
 
   // Buffer
diff --git a/wpinet/src/main/native/include/wpi/net/NetworkStream.hpp b/wpinet/src/main/native/include/wpi/net/NetworkStream.hpp
index 007dbbc6ee..0fcb1eace6 100644
--- a/wpinet/src/main/native/include/wpi/net/NetworkStream.hpp
+++ b/wpinet/src/main/native/include/wpi/net/NetworkStream.hpp
@@ -14,11 +14,11 @@ class NetworkStream {
   NetworkStream() = default;
   virtual ~NetworkStream() = default;
 
-  enum Error {
-    kConnectionClosed = 0,
-    kConnectionReset = -1,
-    kConnectionTimedOut = -2,
-    kWouldBlock = -3
+  enum class Error {
+    CONNECTION_CLOSED = 0,
+    CONNECTION_RESET = -1,
+    CONNECTION_TIMED_OUT = -2,
+    WOULD_BLOCK = -3
   };
 
   virtual size_t send(const char* buffer, size_t len, Error* err) = 0;
diff --git a/wpinet/src/main/native/include/wpi/net/WebSocket.hpp b/wpinet/src/main/native/include/wpi/net/WebSocket.hpp
index 863c26b62d..3db4dae2c2 100644
--- a/wpinet/src/main/native/include/wpi/net/WebSocket.hpp
+++ b/wpinet/src/main/native/include/wpi/net/WebSocket.hpp
@@ -33,15 +33,15 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
   struct private_init {};
 
  public:
-  static constexpr uint8_t kOpCont = 0x00;
-  static constexpr uint8_t kOpText = 0x01;
-  static constexpr uint8_t kOpBinary = 0x02;
-  static constexpr uint8_t kOpClose = 0x08;
-  static constexpr uint8_t kOpPing = 0x09;
-  static constexpr uint8_t kOpPong = 0x0A;
-  static constexpr uint8_t kOpMask = 0x0F;
-  static constexpr uint8_t kFlagFin = 0x80;
-  static constexpr uint8_t kFlagControl = 0x08;
+  static constexpr uint8_t OP_CONT = 0x00;
+  static constexpr uint8_t OP_TEXT = 0x01;
+  static constexpr uint8_t OP_BINARY = 0x02;
+  static constexpr uint8_t OP_CLOSE = 0x08;
+  static constexpr uint8_t OP_PING = 0x09;
+  static constexpr uint8_t OP_PONG = 0x0A;
+  static constexpr uint8_t OP_MASK = 0x0F;
+  static constexpr uint8_t FLAG_FIN = 0x80;
+  static constexpr uint8_t FLAG_CONTROL = 0x08;
 
   WebSocket(uv::Stream& stream, bool server, const private_init&);
   WebSocket(const WebSocket&) = delete;
@@ -53,7 +53,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
   /**
    * Connection states.
    */
-  enum State {
+  enum class State {
     /** The connection is not yet open. */
     CONNECTING = 0,
     /** The connection is open and ready to communicate. */
@@ -83,14 +83,14 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
    * Frame.  Used by SendFrames().
    */
   struct Frame {
-    static constexpr uint8_t kText = kFlagFin | kOpText;
-    static constexpr uint8_t kBinary = kFlagFin | kOpBinary;
-    static constexpr uint8_t kTextFragment = kOpText;
-    static constexpr uint8_t kBinaryFragment = kOpBinary;
-    static constexpr uint8_t kFragment = kOpCont;
-    static constexpr uint8_t kFinalFragment = kFlagFin | kOpCont;
-    static constexpr uint8_t kPing = kFlagFin | kOpPing;
-    static constexpr uint8_t kPong = kFlagFin | kOpPong;
+    static constexpr uint8_t TEXT = FLAG_FIN | OP_TEXT;
+    static constexpr uint8_t BINARY = FLAG_FIN | OP_BINARY;
+    static constexpr uint8_t TEXT_FRAGMENT = OP_TEXT;
+    static constexpr uint8_t BINARY_FRAGMENT = OP_BINARY;
+    static constexpr uint8_t FRAGMENT = OP_CONT;
+    static constexpr uint8_t FINAL_FRAGMENT = FLAG_FIN | OP_CONT;
+    static constexpr uint8_t PING = FLAG_FIN | OP_PING;
+    static constexpr uint8_t PONG = FLAG_FIN | OP_PONG;
 
     constexpr Frame(uint8_t opcode, std::span<const uv::Buffer> data)
         : opcode{opcode}, data{data} {}
@@ -158,7 +158,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
    * Return if the connection is open.  Messages can only be sent on open
    * connections.
    */
-  bool IsOpen() const { return m_state == OPEN; }
+  bool IsOpen() const { return m_state == State::OPEN; }
 
   /**
    * Get the underlying stream.
@@ -202,7 +202,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
   void SendText(
       std::span<const uv::Buffer> data,
       std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
-    Send(kFlagFin | kOpText, data, std::move(callback));
+    Send(FLAG_FIN | OP_TEXT, data, std::move(callback));
   }
 
   /**
@@ -224,7 +224,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
   void SendBinary(
       std::span<const uv::Buffer> data,
       std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
-    Send(kFlagFin | kOpBinary, data, std::move(callback));
+    Send(FLAG_FIN | OP_BINARY, data, std::move(callback));
   }
 
   /**
@@ -248,7 +248,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
   void SendTextFragment(
       std::span<const uv::Buffer> data,
       std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
-    Send(kOpText, data, std::move(callback));
+    Send(OP_TEXT, data, std::move(callback));
   }
 
   /**
@@ -274,7 +274,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
   void SendBinaryFragment(
       std::span<const uv::Buffer> data,
       std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
-    Send(kOpBinary, data, std::move(callback));
+    Send(OP_BINARY, data, std::move(callback));
   }
 
   /**
@@ -300,7 +300,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
   void SendFragment(
       std::span<const uv::Buffer> data, bool fin,
       std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
-    Send(kOpCont | (fin ? kFlagFin : 0), data, std::move(callback));
+    Send(OP_CONT | (fin ? FLAG_FIN : 0), data, std::move(callback));
   }
 
   /**
@@ -338,7 +338,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
   void SendPing(
       std::span<const uv::Buffer> data,
       std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
-    SendControl(kFlagFin | kOpPing, data, std::move(callback));
+    SendControl(FLAG_FIN | OP_PING, data, std::move(callback));
   }
 
   /**
@@ -375,7 +375,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
   void SendPong(
       std::span<const uv::Buffer> data,
       std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
-    SendControl(kFlagFin | kOpPong, data, std::move(callback));
+    SendControl(FLAG_FIN | OP_PONG, data, std::move(callback));
   }
 
   /**
@@ -522,7 +522,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
   std::weak_ptr<WriteReq> m_lastWriteReq;
 
   // operating state
-  State m_state = CONNECTING;
+  State m_state = State::CONNECTING;
 
   // incoming message buffers/state
   uint64_t m_lastReceivedTime = 0;
diff --git a/wpinet/src/main/native/include/wpi/net/WebSocketServer.hpp b/wpinet/src/main/native/include/wpi/net/WebSocketServer.hpp
index 9e443b99be..054e186f0e 100644
--- a/wpinet/src/main/native/include/wpi/net/WebSocketServer.hpp
+++ b/wpinet/src/main/native/include/wpi/net/WebSocketServer.hpp
@@ -172,7 +172,7 @@ class WebSocketServer : public std::enable_shared_from_this<WebSocketServer> {
 
  private:
   uv::Stream& m_stream;
-  HttpParser m_req{HttpParser::kRequest};
+  HttpParser m_req{HttpParser::Type::REQUEST};
   WebSocketServerHelper m_helper;
   wpi::util::SmallVector<std::string, 2> m_protocols;
   ServerOptions m_options;
diff --git a/wpinet/src/main/native/include/wpi/net/uv/Loop.hpp b/wpinet/src/main/native/include/wpi/net/uv/Loop.hpp
index b2358795b2..5360150b83 100644
--- a/wpinet/src/main/native/include/wpi/net/uv/Loop.hpp
+++ b/wpinet/src/main/native/include/wpi/net/uv/Loop.hpp
@@ -6,7 +6,6 @@
 
 #include <atomic>
 #include <chrono>
-#include <functional>
 #include <memory>
 #include <thread>
 #include <utility>
@@ -38,10 +37,10 @@ class Loop final : public std::enable_shared_from_this<Loop> {
  public:
   using Time = std::chrono::duration<uint64_t, std::milli>;
 
-  enum Mode {
-    kDefault = UV_RUN_DEFAULT,
-    kOnce = UV_RUN_ONCE,
-    kNoWait = UV_RUN_NOWAIT
+  enum class Mode {
+    DEFAULT = UV_RUN_DEFAULT,
+    ONCE = UV_RUN_ONCE,
+    NO_WAIT = UV_RUN_NOWAIT
   };
 
   explicit Loop(const private_init&) noexcept;
@@ -97,16 +96,16 @@ class Loop final : public std::enable_shared_from_this<Loop> {
    *
    * Available modes are:
    *
-   * * `Loop::kDefault`: Run the event loop until there are no
+   * * `Mode::DEFAULT`: Run the event loop until there are no
    *                     active and referenced handles or requests.
-   * * `Loop::kOnce`: Run a single event loop iteration. Note that this
+   * * `Mode::ONCE`: Run a single event loop iteration. Note that this
    *                  function blocks if there are no pending callbacks.
-   * * `Loop::kNoWait`: Run a single event loop iteration, but don't block
+   * * `Mode::NO_WAIT`: Run a single event loop iteration, but don't block
    *                    if there are no pending callbacks.
    *
    * @return True when done, false in all other cases.
    */
-  bool Run(Mode mode = kDefault) {
+  bool Run(Mode mode = Mode::DEFAULT) {
     m_tid = std::this_thread::get_id();
     int rv = uv_run(m_loop, static_cast<uv_run_mode>(static_cast<int>(mode)));
     m_tid = std::thread::id{};
@@ -134,7 +133,7 @@ class Loop final : public std::enable_shared_from_this<Loop> {
    * Get backend file descriptor.
    *
    * Only kqueue, epoll and event ports are supported.
-   * This can be used in conjunction with `run(Loop::kNoWait)` to poll
+   * This can be used in conjunction with `run(Loop::NO_WAIT)` to poll
    * in one thread and run the event loop’s callbacks in another.
    *
    * @return The backend file descriptor.
diff --git a/wpinet/src/main/native/include/wpi/net/uv/Process.hpp b/wpinet/src/main/native/include/wpi/net/uv/Process.hpp
index bd33f2eb27..86db99cf27 100644
--- a/wpinet/src/main/native/include/wpi/net/uv/Process.hpp
+++ b/wpinet/src/main/native/include/wpi/net/uv/Process.hpp
@@ -39,22 +39,22 @@ class Process final : public HandleImpl<Process, uv_process_t> {
    * what it points to.
    */
   struct Option {
-    enum Type {
-      kNone,
-      kArg,
-      kEnv,
-      kCwd,
-      kUid,
-      kGid,
-      kSetFlags,
-      kClearFlags,
-      kStdioIgnore,
-      kStdioInheritFd,
-      kStdioInheritPipe,
-      kStdioCreatePipe
+    enum class Type {
+      NONE,
+      ARG,
+      ENV,
+      WORKING_DIRECTORY,
+      USER_ID,
+      GROUP_ID,
+      SET_FLAGS,
+      CLEAR_FLAGS,
+      STDIO_IGNORE,
+      STDIO_INHERIT_FD,
+      STDIO_INHERIT_PIPE,
+      STDIO_CREATE_PIPE
     };
 
-    Option() : m_type(kNone) {}
+    Option() : m_type(Type::NONE) {}
 
     /*implicit*/ Option(const char* arg) {  // NOLINT
       m_data.str = arg;
@@ -76,7 +76,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
 
     explicit Option(Type type) : m_type(type) {}
 
-    Type m_type = kArg;
+    Type m_type = Type::ARG;
     std::string m_strData;
     union {
       const char* str;
@@ -100,7 +100,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
    * @param env environment variable
    */
   static Option Env(std::string_view env) {
-    Option o(Option::kEnv);
+    Option o(Option::Type::ENV);
     o.m_strData = env;
     o.m_data.str = o.m_strData.c_str();
     return o;
@@ -111,7 +111,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
    * @param cwd current working directory
    */
   static Option Cwd(std::string_view cwd) {
-    Option o(Option::kCwd);
+    Option o(Option::Type::WORKING_DIRECTORY);
     o.m_strData = cwd;
     o.m_data.str = o.m_strData.c_str();
     return o;
@@ -122,7 +122,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
    * @param uid user id
    */
   static Option Uid(uv_uid_t uid) {
-    Option o(Option::kUid);
+    Option o(Option::Type::USER_ID);
     o.m_data.uid = uid;
     return o;
   }
@@ -132,7 +132,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
    * @param gid group id
    */
   static Option Gid(uv_gid_t gid) {
-    Option o(Option::kGid);
+    Option o(Option::Type::GROUP_ID);
     o.m_data.gid = gid;
     return o;
   }
@@ -142,7 +142,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
    * @param flags Bitmask values from uv_process_flags.
    */
   static Option SetFlags(unsigned int flags) {
-    Option o(Option::kSetFlags);
+    Option o(Option::Type::SET_FLAGS);
     o.m_data.flags = flags;
     return o;
   }
@@ -152,7 +152,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
    * @param flags Bitmask values from uv_process_flags.
    */
   static Option ClearFlags(unsigned int flags) {
-    Option o(Option::kClearFlags);
+    Option o(Option::Type::CLEAR_FLAGS);
     o.m_data.flags = flags;
     return o;
   }
@@ -162,7 +162,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
    * @param index stdio index
    */
   static Option StdioIgnore(size_t index) {
-    Option o(Option::kStdioIgnore);
+    Option o(Option::Type::STDIO_IGNORE);
     o.m_data.stdio.index = index;
     return o;
   }
@@ -173,7 +173,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
    * @param fd parent file descriptor
    */
   static Option StdioInherit(size_t index, int fd) {
-    Option o(Option::kStdioInheritFd);
+    Option o(Option::Type::STDIO_INHERIT_FD);
     o.m_data.stdio.index = index;
     o.m_data.stdio.fd = fd;
     return o;
@@ -185,7 +185,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
    * @param pipe pipe
    */
   static Option StdioInherit(size_t index, Pipe& pipe) {
-    Option o(Option::kStdioInheritPipe);
+    Option o(Option::Type::STDIO_INHERIT_PIPE);
     o.m_data.stdio.index = index;
     o.m_data.stdio.pipe = &pipe;
     return o;
@@ -199,7 +199,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
    *              UV_OVERLAPPED_PIPE (Windows only, ignored on Unix).
    */
   static Option StdioCreatePipe(size_t index, Pipe& pipe, unsigned int flags) {
-    Option o(Option::kStdioCreatePipe);
+    Option o(Option::Type::STDIO_CREATE_PIPE);
     o.m_data.stdio.index = index;
     o.m_data.stdio.pipe = &pipe;
     o.m_data.stdio.flags = flags;
diff --git a/wpinet/src/main/native/thirdparty/tcpsockets/cpp/TCPStream.cpp b/wpinet/src/main/native/thirdparty/tcpsockets/cpp/TCPStream.cpp
index e8c10ea029..0ac20bec94 100644
--- a/wpinet/src/main/native/thirdparty/tcpsockets/cpp/TCPStream.cpp
+++ b/wpinet/src/main/native/thirdparty/tcpsockets/cpp/TCPStream.cpp
@@ -65,7 +65,7 @@ TCPStream::~TCPStream() {
 
 size_t TCPStream::send(const char* buffer, size_t len, Error* err) {
   if (m_sd < 0) {
-    *err = kConnectionClosed;
+    *err = Error::CONNECTION_CLOSED;
     return 0;
   }
 #ifdef _WIN32
@@ -80,7 +80,7 @@ size_t TCPStream::send(const char* buffer, size_t len, Error* err) {
       break;
     }
     if (!m_blocking) {
-      *err = kWouldBlock;
+      *err = Error::WOULD_BLOCK;
       return 0;
     }
     Sleep(1);
@@ -91,7 +91,7 @@ size_t TCPStream::send(const char* buffer, size_t len, Error* err) {
                            "Send() failed: WSA error={}\n", WSAGetLastError());
 
     OutputDebugStringA(Buffer);
-    *err = kConnectionReset;
+    *err = Error::CONNECTION_RESET;
     return 0;
   }
 #else
@@ -103,9 +103,9 @@ size_t TCPStream::send(const char* buffer, size_t len, Error* err) {
 #endif
   if (rv < 0) {
     if (!m_blocking && (errno == EAGAIN || errno == EWOULDBLOCK)) {
-      *err = kWouldBlock;
+      *err = Error::WOULD_BLOCK;
     } else {
-      *err = kConnectionReset;
+      *err = Error::CONNECTION_RESET;
     }
     return 0;
   }
@@ -115,7 +115,7 @@ size_t TCPStream::send(const char* buffer, size_t len, Error* err) {
 
 size_t TCPStream::receive(char* buffer, size_t len, Error* err, int timeout) {
   if (m_sd < 0) {
-    *err = kConnectionClosed;
+    *err = Error::CONNECTION_CLOSED;
     return 0;
   }
 #ifdef _WIN32
@@ -136,7 +136,7 @@ size_t TCPStream::receive(char* buffer, size_t len, Error* err, int timeout) {
     rv = read(m_sd, buffer, len);
 #endif
   } else {
-    *err = kConnectionTimedOut;
+    *err = Error::CONNECTION_TIMED_OUT;
     return 0;
   }
   if (rv < 0) {
@@ -145,9 +145,9 @@ size_t TCPStream::receive(char* buffer, size_t len, Error* err, int timeout) {
 #else
     if (!m_blocking && (errno == EAGAIN || errno == EWOULDBLOCK)) {
 #endif
-      *err = kWouldBlock;
+      *err = Error::WOULD_BLOCK;
     } else {
-      *err = kConnectionReset;
+      *err = Error::CONNECTION_RESET;
     }
     return 0;
   }
diff --git a/wpinet/src/test/native/cpp/HttpParserTest.cpp b/wpinet/src/test/native/cpp/HttpParserTest.cpp
index d2c608d6ae..1b90e85348 100644
--- a/wpinet/src/test/native/cpp/HttpParserTest.cpp
+++ b/wpinet/src/test/native/cpp/HttpParserTest.cpp
@@ -9,7 +9,7 @@
 namespace wpi::net {
 
 TEST(HttpParserTest, UrlMethodHeadersComplete) {
-  HttpParser p{HttpParser::kRequest};
+  HttpParser p{HttpParser::Type::REQUEST};
   int callbacks = 0;
   p.url.connect([&](std::string_view path) {
     ASSERT_EQ(path, "/foo/bar");
@@ -27,7 +27,7 @@ TEST(HttpParserTest, UrlMethodHeadersComplete) {
 }
 
 TEST(HttpParserTest, UrlMethodHeader) {
-  HttpParser p{HttpParser::kRequest};
+  HttpParser p{HttpParser::Type::REQUEST};
   int callbacks = 0;
   p.url.connect([&](std::string_view path) {
     ASSERT_EQ(path, "/foo/bar");
@@ -47,7 +47,7 @@ TEST(HttpParserTest, UrlMethodHeader) {
 }
 
 TEST(HttpParserTest, StatusHeadersComplete) {
-  HttpParser p{HttpParser::kResponse};
+  HttpParser p{HttpParser::Type::RESPONSE};
   int callbacks = 0;
   p.status.connect([&](std::string_view status) {
     ASSERT_EQ(status, "OK");
@@ -64,7 +64,7 @@ TEST(HttpParserTest, StatusHeadersComplete) {
 }
 
 TEST(HttpParserTest, StatusHeader) {
-  HttpParser p{HttpParser::kResponse};
+  HttpParser p{HttpParser::Type::RESPONSE};
   int callbacks = 0;
   p.status.connect([&](std::string_view status) {
     ASSERT_EQ(status, "OK");
@@ -81,7 +81,7 @@ TEST(HttpParserTest, StatusHeader) {
 }
 
 TEST(HttpParserTest, HeaderFieldComplete) {
-  HttpParser p{HttpParser::kRequest};
+  HttpParser p{HttpParser::Type::REQUEST};
   int callbacks = 0;
   p.header.connect([&](std::string_view name, std::string_view value) {
     ASSERT_EQ(name, "Foo");
@@ -104,7 +104,7 @@ TEST(HttpParserTest, HeaderFieldComplete) {
 }
 
 TEST(HttpParserTest, HeaderFieldNext) {
-  HttpParser p{HttpParser::kRequest};
+  HttpParser p{HttpParser::Type::REQUEST};
   int callbacks = 0;
   p.header.connect([&](std::string_view name, std::string_view value) {
     ASSERT_EQ(name, "Foo");
@@ -127,7 +127,7 @@ TEST(HttpParserTest, HeaderFieldNext) {
 }
 
 TEST(HttpParserTest, HeadersComplete) {
-  HttpParser p{HttpParser::kRequest};
+  HttpParser p{HttpParser::Type::REQUEST};
   int callbacks = 0;
   p.headersComplete.connect([&](bool keepAlive) {
     ASSERT_EQ(keepAlive, false);
@@ -141,7 +141,7 @@ TEST(HttpParserTest, HeadersComplete) {
 }
 
 TEST(HttpParserTest, HeadersCompleteHTTP11) {
-  HttpParser p{HttpParser::kRequest};
+  HttpParser p{HttpParser::Type::REQUEST};
   int callbacks = 0;
   p.headersComplete.connect([&](bool keepAlive) {
     ASSERT_EQ(keepAlive, true);
@@ -155,7 +155,7 @@ TEST(HttpParserTest, HeadersCompleteHTTP11) {
 }
 
 TEST(HttpParserTest, HeadersCompleteKeepAlive) {
-  HttpParser p{HttpParser::kRequest};
+  HttpParser p{HttpParser::Type::REQUEST};
   int callbacks = 0;
   p.headersComplete.connect([&](bool keepAlive) {
     ASSERT_EQ(keepAlive, true);
@@ -171,7 +171,7 @@ TEST(HttpParserTest, HeadersCompleteKeepAlive) {
 }
 
 TEST(HttpParserTest, HeadersCompleteUpgrade) {
-  HttpParser p{HttpParser::kRequest};
+  HttpParser p{HttpParser::Type::REQUEST};
   int callbacks = 0;
   p.headersComplete.connect([&](bool) {
     ASSERT_TRUE(p.IsUpgrade());
@@ -188,14 +188,14 @@ TEST(HttpParserTest, HeadersCompleteUpgrade) {
 }
 
 TEST(HttpParserTest, Reset) {
-  HttpParser p{HttpParser::kRequest};
+  HttpParser p{HttpParser::Type::REQUEST};
   int callbacks = 0;
   p.headersComplete.connect([&](bool) { ++callbacks; });
   p.Execute("GET / HTTP/1.1\r\n");
   ASSERT_EQ(callbacks, 0);
   p.Execute("\r\n");
   ASSERT_EQ(callbacks, 1);
-  p.Reset(HttpParser::kRequest);
+  p.Reset(HttpParser::Type::REQUEST);
   p.Execute("GET / HTTP/1.1\r\n");
   ASSERT_EQ(callbacks, 1);
   p.Execute("\r\n");
diff --git a/wpinet/src/test/native/cpp/WebSocketClientTest.cpp b/wpinet/src/test/native/cpp/WebSocketClientTest.cpp
index fb66f86a1b..71c25a7b6d 100644
--- a/wpinet/src/test/native/cpp/WebSocketClientTest.cpp
+++ b/wpinet/src/test/native/cpp/WebSocketClientTest.cpp
@@ -94,7 +94,7 @@ class WebSocketClientTest : public WebSocketTest {
   bool mockBadAccept = false;
   std::vector<uint8_t> wireData;
   std::shared_ptr<uv::Pipe> conn;
-  HttpParser req{HttpParser::kRequest};
+  HttpParser req{HttpParser::Type::REQUEST};
   wpi::util::SmallString<64> clientKey;
   std::string mockProtocol;
   bool serverHeadersDone = false;
diff --git a/wpinet/src/test/native/cpp/WebSocketSerializerTest.cpp b/wpinet/src/test/native/cpp/WebSocketSerializerTest.cpp
index 62981e3d97..31908422fd 100644
--- a/wpinet/src/test/native/cpp/WebSocketSerializerTest.cpp
+++ b/wpinet/src/test/native/cpp/WebSocketSerializerTest.cpp
@@ -217,9 +217,9 @@ const std::array<uv::Buffer, 2> WebSocketTrySendTest::m_frame0bufs{m_bufs[0],
 const std::array<uv::Buffer, 1> WebSocketTrySendTest::m_frame1bufs{m_bufs[2]};
 const std::array<uv::Buffer, 1> WebSocketTrySendTest::m_frame2bufs{m_bufs[3]};
 const std::array<WebSocket::Frame, 3> WebSocketTrySendTest::m_frames{
-    WebSocket::Frame{WebSocket::Frame::kBinaryFragment, m_frame0bufs},
-    WebSocket::Frame{WebSocket::Frame::kBinary, m_frame1bufs},
-    WebSocket::Frame{WebSocket::Frame::kText, m_frame2bufs},
+    WebSocket::Frame{WebSocket::Frame::BINARY_FRAGMENT, m_frame0bufs},
+    WebSocket::Frame{WebSocket::Frame::BINARY, m_frame1bufs},
+    WebSocket::Frame{WebSocket::Frame::TEXT, m_frame2bufs},
 };
 const std::array<std::vector<uint8_t>, 3> WebSocketTrySendTest::m_serialized{
     WebSocketTest::BuildMessage(m_frames[0].opcode, false, false, m_frame0data),
@@ -395,7 +395,7 @@ TEST_F(WebSocketTrySendTest, Big) {
     bufs.emplace_back(
         uv::Buffer::Allocate(i < 100000 ? 1430 : (100000 - (i - 1430))));
   }
-  WebSocket::Frame frame{WebSocket::kOpBinary | WebSocket::kFlagFin, bufs};
+  WebSocket::Frame frame{WebSocket::OP_BINARY | WebSocket::FLAG_FIN, bufs};
   EXPECT_CALL(stream, TryWrite(_)).WillOnce(Return(7681));
 
   // Write called for remainder of buffers
diff --git a/wpinet/src/test/native/cpp/WebSocketServerTest.cpp b/wpinet/src/test/native/cpp/WebSocketServerTest.cpp
index 60ea8fa9fd..c870d8d392 100644
--- a/wpinet/src/test/native/cpp/WebSocketServerTest.cpp
+++ b/wpinet/src/test/native/cpp/WebSocketServerTest.cpp
@@ -58,7 +58,7 @@ class WebSocketServerTest : public WebSocketTest {
   std::function<void(std::string_view)> handleData;
   std::vector<uint8_t> wireData;
   std::shared_ptr<WebSocket> ws;
-  HttpParser resp{HttpParser::kResponse};
+  HttpParser resp{HttpParser::Type::RESPONSE};
   bool headersDone = false;
 };
 
diff --git a/wpinet/src/test/native/cpp/WebSocketTest.cpp b/wpinet/src/test/native/cpp/WebSocketTest.cpp
index 25a1c0b9bf..bfcbb3fac5 100644
--- a/wpinet/src/test/native/cpp/WebSocketTest.cpp
+++ b/wpinet/src/test/native/cpp/WebSocketTest.cpp
@@ -107,7 +107,7 @@ TEST_F(WebSocketTest, CreateClientBasic) {
   int gotKey = 0;
   int gotVersion = 0;
 
-  HttpParser req{HttpParser::kRequest};
+  HttpParser req{HttpParser::Type::REQUEST};
   req.url.connect([](std::string_view url) { ASSERT_EQ(url, "/test"); });
   req.header.connect([&](std::string_view name, std::string_view value) {
     if (wpi::util::equals_lower(name, "host")) {
@@ -160,7 +160,7 @@ TEST_F(WebSocketTest, CreateClientBasic) {
 TEST_F(WebSocketTest, CreateClientExtraHeaders) {
   int gotExtra1 = 0;
   int gotExtra2 = 0;
-  HttpParser req{HttpParser::kRequest};
+  HttpParser req{HttpParser::Type::REQUEST};
   req.header.connect([&](std::string_view name, std::string_view value) {
     if (wpi::util::equals(name, "Extra1")) {
       ASSERT_EQ(value, "Data1");
@@ -233,7 +233,7 @@ TEST_F(WebSocketTest, CreateServerBasic) {
   int gotAccept = 0;
   int gotOpen = 0;
 
-  HttpParser resp{HttpParser::kResponse};
+  HttpParser resp{HttpParser::Type::RESPONSE};
   resp.status.connect([&](std::string_view status) {
     ++gotStatus;
     ASSERT_EQ(resp.GetStatusCode(), 101u) << "status: " << status;
@@ -289,7 +289,7 @@ TEST_F(WebSocketTest, CreateServerProtocol) {
   int gotProtocol = 0;
   int gotOpen = 0;
 
-  HttpParser resp{HttpParser::kResponse};
+  HttpParser resp{HttpParser::Type::RESPONSE};
   resp.header.connect([&](std::string_view name, std::string_view value) {
     if (wpi::util::equals_lower(name, "sec-websocket-protocol")) {
       ++gotProtocol;
@@ -331,7 +331,7 @@ TEST_F(WebSocketTest, CreateServerBadVersion) {
   int gotVersion = 0;
   int gotUpgrade = 0;
 
-  HttpParser resp{HttpParser::kResponse};
+  HttpParser resp{HttpParser::Type::RESPONSE};
   resp.status.connect([&](std::string_view status) {
     ++gotStatus;
     ASSERT_EQ(resp.GetStatusCode(), 426u) << "status: " << status;