diff --git a/api/kernel/rng.hpp b/api/kernel/rng.hpp
index 21db5bf41..ba975573e 100644
--- a/api/kernel/rng.hpp
+++ b/api/kernel/rng.hpp
@@ -24,6 +24,9 @@
 #include <cstdint>
 #include <delegate>
 #include <smp_utils>
+#ifdef INCLUDEOS_SMP_ENABLE
+#include <mutex>
+#endif
 
 // Incorporate seed data into the system RNG state
 extern void rng_absorb(const void* input, size_t bytes);
diff --git a/api/net/buffer_store.hpp b/api/net/buffer_store.hpp
index 152a155fb..9694e9a08 100644
--- a/api/net/buffer_store.hpp
+++ b/api/net/buffer_store.hpp
@@ -23,6 +23,9 @@
 #include <vector>
 #include <smp>
 #include <likely>
+#ifdef INCLUDEOS_SMP_ENABLE
+#include <mutex>
+#endif
 
 namespace net
 {
diff --git a/api/posix/tcp_fd.hpp b/api/posix/tcp_fd.hpp
index fad3db418..82d387ae1 100644
--- a/api/posix/tcp_fd.hpp
+++ b/api/posix/tcp_fd.hpp
@@ -21,9 +21,30 @@
 
 #include "sockfd.hpp"
 
-struct TCP_FD_Conn;
 struct TCP_FD_Listen;
 
+struct TCP_FD_Conn
+{
+  TCP_FD_Conn(net::tcp::Connection_ptr c);
+  ~TCP_FD_Conn() = default;
+
+  void retrieve_buffer();
+  void set_default_read();
+
+  ssize_t send(const void *, size_t, int fl);
+  ssize_t recv(void*, size_t, int fl);
+  int     close();
+  int     shutdown(int);
+
+  std::string to_string() const { return conn->to_string(); }
+
+  net::tcp::Connection_ptr conn;
+  net::tcp::buffer_t buffer;
+  size_t buf_offset;
+  bool recv_disc = false;
+};
+
+
 class TCP_FD : public SockFD {
 public:
   using id_t = int;
@@ -68,25 +89,6 @@ class TCP_FD : public SockFD {
   friend struct TCP_FD_Listen;
 };
 
-struct TCP_FD_Conn
-{
-  TCP_FD_Conn(net::tcp::Connection_ptr c);
-
-  void retrieve_buffer();
-  void set_default_read();
-
-  ssize_t send(const void *, size_t, int fl);
-  ssize_t recv(void*, size_t, int fl);
-  int     close();
-  int     shutdown(int);
-
-  std::string to_string() const { return conn->to_string(); }
-
-  net::tcp::Connection_ptr conn;
-  net::tcp::buffer_t buffer;
-  size_t buf_offset;
-  bool recv_disc = false;
-};
 
 struct TCP_FD_Listen
 {
diff --git a/api/util/delegate.hpp b/api/util/delegate.hpp
index 4343d1234..f4b4d04b1 100644
--- a/api/util/delegate.hpp
+++ b/api/util/delegate.hpp
@@ -21,6 +21,7 @@
 #include <type_traits>
 #include <functional>
 #include <memory>
+#include <new> // std::launder
 
 // ----- SYNOPSIS -----
 
@@ -68,6 +69,20 @@ class empty_delegate_error : public std::bad_function_call
     }
 };
 
+template<std::size_t Size, std::size_t Align>
+struct sbo_storage {
+  alignas(Align) std::byte data[Size];
+
+  template<class T>
+  constexpr T& as() noexcept {
+    return *std::launder(reinterpret_cast<T*>(data));
+  }
+  template<class T>
+  constexpr const T& as() const noexcept {
+    return *std::launder(reinterpret_cast<const T*>(data));
+  }
+};
+
 // ----- IMPLEMENTATION -----
 
 namespace detail
@@ -163,7 +178,7 @@ template<
 > class inplace_triv
 {
 public:
-	using storage_t = std::aligned_storage_t<size, align>;
+	using storage_t = sbo_storage<size, align>;
 	using invoke_ptr_t = R(*)(storage_t&, Args&&...);
 
 	explicit inplace_triv() noexcept :
@@ -178,7 +193,10 @@ template<
 	> explicit inplace_triv(T&& closure) :
 		invoke_ptr_{ static_cast<invoke_ptr_t>(
 			[](storage_t& storage, Args&&... args) -> R
-			{ return reinterpret_cast<C&>(storage)(std::forward<Args>(args)...); }
+			{
+        auto& closure = storage.template as<C>();
+        return closure(std::forward<Args>(args)...);
+      }
 		)}
 	{
 		static_assert(sizeof(C) <= size,
@@ -211,12 +229,12 @@ template<
 
 	bool empty() const noexcept
 	{
-		return reinterpret_cast<std::nullptr_t&>(storage_) == nullptr;
+		return storage_.template as <std::nullptr_t&>() == nullptr;
 	}
 
 	template<typename T> T* target() const noexcept
 	{
-		return reinterpret_cast<T*>(&storage_);
+		return &storage_.template as<T*>();
 	}
 
 private:
@@ -233,7 +251,7 @@ template<
 > class inplace
 {
 public:
-	using storage_t = std::aligned_storage_t<size, align>;
+	using storage_t = sbo_storage<size, align>;
 
 	using invoke_ptr_t = R(*)(storage_t&, Args&&...);
 	using copy_ptr_t = void(*)(storage_t&, storage_t&);
@@ -251,12 +269,18 @@ template<
 	> explicit inplace(T&& closure) noexcept :
 		invoke_ptr_{ static_cast<invoke_ptr_t>(
 			[](storage_t& storage, Args&&... args) -> R
-			{ return reinterpret_cast<C&>(storage)(std::forward<Args>(args)...); }
+			{
+        auto& closure = storage.template as<C>();
+        return closure(std::forward<Args>(args)...);
+      }
 		) },
 		copy_ptr_{ copy_op<C, storage_t>() },
 		destructor_ptr_{ static_cast<destructor_ptr_t>(
 			[](storage_t& storage) noexcept -> void
-			{ reinterpret_cast<C&>(storage).~C(); }
+			{
+        auto& closure = storage.template as<C>();
+        closure.~C();
+      }
 		) }
 	{
 		static_assert(sizeof(C) <= size,
@@ -337,7 +361,7 @@ template<
 
 	template<typename T> T* target() const noexcept
 	{
-		return reinterpret_cast<T*>(&storage_);
+		return &storage_.template as <T>();
 	}
 
 private:
@@ -357,7 +381,7 @@ template<
 	{
 		return [](S& dst, S& src) noexcept -> void
 		{
-			new(&dst)T{ reinterpret_cast<T&>(src) };
+			new(&dst)T{ src.template as<T>() };
 		};
 	}
 
diff --git a/api/util/fixed_vector.hpp b/api/util/fixed_vector.hpp
index 3508ac70e..7c5e508f9 100644
--- a/api/util/fixed_vector.hpp
+++ b/api/util/fixed_vector.hpp
@@ -29,6 +29,7 @@
 #include <cassert>
 #include <type_traits>
 #include <iterator>
+#include <new>
 
 enum class Fixedvector_Init {
   UNINIT
@@ -54,14 +55,14 @@ class Fixed_vector {
   T& push_back(const T& e) noexcept {
     assert(count < N);
     (*this)[count] = e;
-    return (*this)[count++];
+    return reinterpret_raw()[count++];
   }
   // construct into
   template <typename... Args>
   T& emplace_back(Args&&... args) noexcept {
     assert(count < N);
-    new (&element[count]) T(args...);
-    return (*this)[count++];
+    new (static_cast<void*>(reinterpret_raw() + count)) T(std::forward<Args>(args)...);
+    return reinterpret_raw()[count++];
   }
 
   /**
@@ -108,36 +109,36 @@ class Fixed_vector {
   { return capacity() - size(); }
 
   T& operator[] (uint32_t i) noexcept {
-    return *(T*) (element + i);
+    return reinterpret_raw()[i];
   }
   T* at (uint32_t i) noexcept {
     if (i >= size()) return nullptr;
-    return (T*) (element + i);
+    return reinterpret_raw() + i;
   }
 
   T* data() noexcept {
-    return (T*) &element[0];
+    return reinterpret_raw();
   }
   T* begin() noexcept {
-    return (T*) &element[0];
+    return reinterpret_raw();
   }
   T* end() noexcept {
-    return (T*) &element[count];
+    return reinterpret_raw() + count;
   }
 
   const T* data() const noexcept {
-    return (T*) &element[0];
+    return reinterpret_raw();
   }
   const T* begin() const noexcept {
-    return (T*) &element[0];
+    return reinterpret_raw();
   }
   const T* end() const noexcept {
-    return (T*) &element[count];
+    return reinterpret_raw() + count;
   }
 
   T& back() noexcept {
     assert(not empty());
-    return (T&)element[count-1];
+    return reinterpret_raw()[count-1];
   }
 
   constexpr int capacity() const noexcept {
@@ -151,7 +152,7 @@ class Fixed_vector {
   // source of the same type T, with @size elements
   // Note: size and capacity are not related, and they don't have to match
   void copy(T* src, uint32_t size) {
-    memcpy(element, src, size * sizeof(T));
+    memcpy(reinterpret_raw(), src, size * sizeof(T));
     count = size;
   }
 
@@ -163,7 +164,10 @@ class Fixed_vector {
 
 private:
   uint32_t count;
-  typename std::aligned_storage<sizeof(T), alignof(T)>::type element[N];
+  alignas(T) std::byte storage[sizeof(T) * N];
+
+  T*       reinterpret_raw()       noexcept { return std::launder(reinterpret_cast<      T*>(storage)); }
+  const T* reinterpret_raw() const noexcept { return std::launder(reinterpret_cast<const T*>(storage)); }
 };
 
 
diff --git a/cmake/includeos.cmake b/cmake/includeos.cmake
index f8a06bf97..6b0eb87b1 100644
--- a/cmake/includeos.cmake
+++ b/cmake/includeos.cmake
@@ -1,6 +1,6 @@
 #includeos standard settings for compilation and linkers
 
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
diff --git a/cmake/library.cmake b/cmake/library.cmake
index cca47bd3d..53cd83605 100644
--- a/cmake/library.cmake
+++ b/cmake/library.cmake
@@ -57,11 +57,11 @@ if (debug)
 endif()
 
 if (CMAKE_COMPILER_IS_GNUCC)
-  set(CMAKE_CXX_FLAGS "-m32 -MMD ${CAPABS} ${WARNS} -nostdlib -fno-omit-frame-pointer -c -std=c++20 -D_LIBCPP_HAS_NO_THREADS=1")
+  set(CMAKE_CXX_FLAGS "-m32 -MMD ${CAPABS} ${WARNS} -nostdlib -fno-omit-frame-pointer -c -std=c++23 -D_LIBCPP_HAS_NO_THREADS=1")
   set(CMAKE_C_FLAGS "-m32 -MMD ${CAPABS} ${WARNS} -nostdlib -fno-omit-frame-pointer -c")
 else()
   # these kinda work with llvm
-  set(CMAKE_CXX_FLAGS "-MMD ${CAPABS} ${OPTIMIZE} ${WARNS} -nostdlib -nostdlibinc -fno-omit-frame-pointer -c -std=c++20 -fno-threadsafe-statics -D_LIBCPP_HAS_NO_THREADS=1")
+  set(CMAKE_CXX_FLAGS "-MMD ${CAPABS} ${OPTIMIZE} ${WARNS} -nostdlib -nostdlibinc -fno-omit-frame-pointer -c -std=c++23 -fno-threadsafe-statics -D_LIBCPP_HAS_NO_THREADS=1")
   set(CMAKE_C_FLAGS "-MMD ${CAPABS} ${OPTIMIZE} ${WARNS} -nostdlib -nostdlibinc -fno-omit-frame-pointer -c")
 endif()
 
diff --git a/cmake/linux.service.cmake b/cmake/linux.service.cmake
index e571bb34f..70af96b41 100644
--- a/cmake/linux.service.cmake
+++ b/cmake/linux.service.cmake
@@ -2,9 +2,9 @@
 #   Linux Userspace CMake script   #
 ####################################
 
-#set(CMAKE_CXX_STANDARD 20)
+#set(CMAKE_CXX_STANDARD 23)
 set(COMMON "-g -O2  -Wall -Wextra")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++20 ${COMMON}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++23 ${COMMON}")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COMMON}")
 
 option(BUILD_PLUGINS "Build all plugins as libraries" OFF)
diff --git a/cmake/os.cmake b/cmake/os.cmake
index bca6ddc07..a82515fe6 100644
--- a/cmake/os.cmake
+++ b/cmake/os.cmake
@@ -2,7 +2,7 @@ if (NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE "Release")
 endif()
 
-set (CMAKE_CXX_STANDARD 20)
+set (CMAKE_CXX_STANDARD 23)
 set (CMAKE_CXX_STANDARD_REQUIRED ON)
 
 
diff --git a/lib/LiveUpdate/CMakeLists.txt b/lib/LiveUpdate/CMakeLists.txt
index 4809165b0..f9a5a8b36 100644
--- a/lib/LiveUpdate/CMakeLists.txt
+++ b/lib/LiveUpdate/CMakeLists.txt
@@ -4,7 +4,7 @@ set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
 
 project(includeos C CXX)
 
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
diff --git a/src/kernel/events.cpp b/src/kernel/events.cpp
index b091bc599..5c6584436 100644
--- a/src/kernel/events.cpp
+++ b/src/kernel/events.cpp
@@ -22,6 +22,9 @@
 #include <smp>
 #include <arch.hpp>
 //#define DEBUG_SMP
+#ifdef INCLUDEOS_SMP_ENABLE
+#include <mutex>
+#endif
 
 static SMP::Array<Events> managers;
 static Spinlock em_lock_;
diff --git a/src/kernel/timers.cpp b/src/kernel/timers.cpp
index 74cf36361..51dbc2a80 100644
--- a/src/kernel/timers.cpp
+++ b/src/kernel/timers.cpp
@@ -8,6 +8,9 @@
 #include <statman>
 #include <map>
 #include <vector>
+#ifdef INCLUDEOS_SMP_ENABLE
+#include <mutex>
+#endif
 
 using namespace std::chrono;
 typedef Timers::duration_t duration_t;
diff --git a/src/net/buffer_store.cpp b/src/net/buffer_store.cpp
index 13eecba20..c6d7e9ebb 100644
--- a/src/net/buffer_store.cpp
+++ b/src/net/buffer_store.cpp
@@ -23,6 +23,9 @@
 #include <smp>
 #include <cstddef>
 #include <likely>
+#ifdef INCLUDEOS_SMP_ENABLE
+#include <mutex>
+#endif
 
 #ifdef __MACH__
 extern void* aligned_alloc(size_t alignment, size_t size);
diff --git a/src/platform/x86_pc/acpi.hpp b/src/platform/x86_pc/acpi.hpp
index e9cb1e2e6..68f387166 100644
--- a/src/platform/x86_pc/acpi.hpp
+++ b/src/platform/x86_pc/acpi.hpp
@@ -23,6 +23,9 @@
 #include <cstddef>
 #include <vector>
 #include <smp_utils>
+#ifdef INCLUDEOS_SMP_ENABLE
+#include <mutex>
+#endif
 
 namespace x86 {
 
diff --git a/src/platform/x86_pc/apic_revenant.cpp b/src/platform/x86_pc/apic_revenant.cpp
index f3354ca71..022c9477f 100644
--- a/src/platform/x86_pc/apic_revenant.cpp
+++ b/src/platform/x86_pc/apic_revenant.cpp
@@ -8,6 +8,7 @@
 #include <os.hpp>
 #include <kernel/rng.hpp>
 #include <kprint>
+#include <mutex>
 
 namespace x86 {
   extern void initialize_cpu_tables_for_cpu(int);
diff --git a/src/platform/x86_pc/x2apic.hpp b/src/platform/x86_pc/x2apic.hpp
index 8bf1946d3..d8de6b5fa 100644
--- a/src/platform/x86_pc/x2apic.hpp
+++ b/src/platform/x86_pc/x2apic.hpp
@@ -26,6 +26,9 @@
 #include <expects>
 #include <debug>
 #include <info>
+#ifdef INCLUDEOS_SMP_ENABLE
+#include <mutex>
+#endif
 
 /// x2APIC MSR offsets ///
 #define x2APIC_ID         0x02
diff --git a/src/platform/x86_pc/xapic.hpp b/src/platform/x86_pc/xapic.hpp
index 75838d5a8..d9bc136bd 100644
--- a/src/platform/x86_pc/xapic.hpp
+++ b/src/platform/x86_pc/xapic.hpp
@@ -26,6 +26,9 @@
 #include <debug>
 #include <expects>
 #include <info>
+#ifdef INCLUDEOS_SMP_ENABLE
+#include <mutex>
+#endif
 
 /// xAPIC MMIO offsets ///
 #define xAPIC_ID         0x20
diff --git a/src/util/logger.cpp b/src/util/logger.cpp
index 2ca9b411a..e165bf083 100644
--- a/src/util/logger.cpp
+++ b/src/util/logger.cpp
@@ -16,6 +16,7 @@
 // limitations under the License.
 
 #include <util/logger.hpp>
+#include <algorithm>
 #include <likely>
 
 Logger::Logger(Log& log, Log::size_type pos)
diff --git a/src/util/statman.cpp b/src/util/statman.cpp
index 41062f847..87cfbc3e5 100644
--- a/src/util/statman.cpp
+++ b/src/util/statman.cpp
@@ -18,6 +18,9 @@
 #include <statman>
 #include <info>
 #include <smp_utils>
+#ifdef INCLUDEOS_SMP_ENABLE
+#include <mutex>
+#endif
 
 // this is done to make sure construction only happens here
 static Statman statman_instance;
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index b26c2a6aa..01f28689d 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.31.6)
 
 project(unittests C CXX)
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
@@ -34,7 +34,7 @@ FILE(WRITE ${CMAKE_BINARY_DIR}/version.h
 
 #include_directories(${CMAKE_BINARY_DIR})
 
-set(CMAKE_C_FLAGS "-g -O0 -std=c11 -Wall -Wextra")
+set(CMAKE_C_FLAGS "-g -O0 -std=c23 -Wall -Wextra")
 
 set(NO_INFO "-DNO_INFO=1")
 if(INFO)
@@ -46,7 +46,7 @@ if (DEBUG_INFO)
   set(NO_DEBUG "")
 endif()
 
-set(CMAKE_CXX_FLAGS "-g -O0 -std=c++20 -Wall -Wextra -Wno-frame-address -Wno-unused-function -Wno-int-to-pointer-cast -D__id_t_defined -DUNITTESTS -DURI_THROW_ON_ERROR ${NO_INFO} ${NO_DEBUG} -DGSL_THROW_ON_CONTRACT_VIOLATION -Dlest_FEATURE_AUTO_REGISTER=1 -DHAVE_LEST_MAIN -DPAGE_SIZE=4096")
+set(CMAKE_CXX_FLAGS "-g -O0 -std=c++23 -Wall -Wextra -Wno-frame-address -Wno-unused-function -Wno-int-to-pointer-cast -D__id_t_defined -DUNITTESTS -DURI_THROW_ON_ERROR ${NO_INFO} ${NO_DEBUG} -DGSL_THROW_ON_CONTRACT_VIOLATION -Dlest_FEATURE_AUTO_REGISTER=1 -DHAVE_LEST_MAIN -DPAGE_SIZE=4096")
 
 set(TEST ${CMAKE_CURRENT_SOURCE_DIR})
 
diff --git a/test/kernel/integration/rng/service.cpp b/test/kernel/integration/rng/service.cpp
index 4791cabfb..fca167b4e 100644
--- a/test/kernel/integration/rng/service.cpp
+++ b/test/kernel/integration/rng/service.cpp
@@ -22,6 +22,7 @@
 #include <cassert>
 #include <info>
 #include <map> // hist
+#include <ctime>  // time()
 
 static const size_t BUFLEN = 4096;
 void Service::start()
diff --git a/test/kernel/integration/spinlocks/service.cpp b/test/kernel/integration/spinlocks/service.cpp
index aece41467..b12e519b0 100644
--- a/test/kernel/integration/spinlocks/service.cpp
+++ b/test/kernel/integration/spinlocks/service.cpp
@@ -1,6 +1,7 @@
 #include <os>
 #include <cassert>
 #include <smp>
+#include <mutex>
 
 void Service::start()
 {
diff --git a/test/kernel/unit/spinlocks.cpp b/test/kernel/unit/spinlocks.cpp
index e6d462c44..ec5439540 100644
--- a/test/kernel/unit/spinlocks.cpp
+++ b/test/kernel/unit/spinlocks.cpp
@@ -2,6 +2,7 @@
 #include <smp_utils>
 #include <thread>
 #include <barrier>
+#include <mutex>
 
 CASE("lock/unlock")
 {
diff --git a/vmbuild/CMakeLists.txt b/vmbuild/CMakeLists.txt
index c06be578a..a76e7c181 100644
--- a/vmbuild/CMakeLists.txt
+++ b/vmbuild/CMakeLists.txt
@@ -4,15 +4,15 @@ project (vmbuilder)
 
 include(CheckCXXCompilerFlag)
 set(CMAKE_BUILD_TYPE Release)
-check_cxx_compiler_flag(-std=c++20 HAVE_FLAG_STD_CXX20)
+check_cxx_compiler_flag(-std=c++23 HAVE_FLAG_STD_CXX20)
 if(NOT HAVE_FLAG_STD_CXX20)
- message(FATAL_ERROR "The provided compiler: " ${CMAKE_CXX_COMPILER} "\n does not support c++20 standard please make sure your CC and CXX points to a compiler that supports c++20")
+ message(FATAL_ERROR "The provided compiler: " ${CMAKE_CXX_COMPILER} "\n does not support c++23 standard please make sure your CC and CXX points to a compiler that supports c++23")
 endif()
 
 set(SOURCES vmbuild.cpp)
 set(ELF_SYMS_SOURCES elf_syms.cpp ../src/util/crc32.cpp)
 
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_FLAGS "-Wall -Wextra -O2 -g")