dev: better .clang-format, ran format command.

Signed-off-by: Amlal <amlal@nekernel.org>

23 files changed, 1070 insertions, 1386 deletions

diff --git a/dev/kernel/NewKit/Array.h b/dev/kernel/NewKit/Array.h
index 1dcc6720..af73d002 100644
--- a/dev/kernel/NewKit/Array.h
+++ b/dev/kernel/NewKit/Array.h
@@ -1,65 +1,46 @@
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
 #pragma once
 
 #include <KernelKit/DebugOutput.h>
-#include <NewKit/ErrorOr.h>
 #include <NewKit/Defines.h>
+#include <NewKit/ErrorOr.h>
 
-namespace Kernel
-{
-	template <typename T, SizeT N>
-	class Array final
-	{
-	public:
-		explicit Array() = default;
-		~Array()		 = default;
+namespace Kernel {
+template <typename T, SizeT N>
+class Array final {
+ public:
+  explicit Array() = default;
+  ~Array()         = default;
 
-		Array& operator=(const Array&) = default;
-		Array(const Array&)			   = default;
+  Array& operator=(const Array&) = default;
+  Array(const Array&)            = default;
 
-		T& operator[](SizeT at)
-		{
-			MUST_PASS(at < this->Count());
-			return fArray[at];
-		}
+  T& operator[](SizeT at) {
+    MUST_PASS(at < this->Count());
+    return fArray[at];
+  }
 
-		Boolean Empty()
-		{
-			return this->Count() > 0;
-		}
+  Boolean Empty() { return this->Count() > 0; }
 
-		SizeT Capacity()
-		{
-			return N;
-		}
+  SizeT Capacity() { return N; }
 
-		SizeT Count()
-		{
-			return N;
-		}
+  SizeT Count() { return N; }
 
-		const T* CData()
-		{
-			return fArray;
-		}
+  const T* CData() { return fArray; }
 
-		operator bool()
-		{
-			return !Empty();
-		}
+  operator bool() { return !Empty(); }
 
-	private:
-		T fArray[N];
-	};
+ private:
+  T fArray[N];
+};
 
-	template <typename ValueType>
-	auto make_list(ValueType val)
-	{
-		return Array<ValueType, ARRAY_SIZE(val)>{val};
-	}
-} // namespace Kernel
+template <typename ValueType>
+auto make_list(ValueType val) {
+  return Array<ValueType, ARRAY_SIZE(val)>{val};
+}
+}  // namespace Kernel
diff --git a/dev/kernel/NewKit/ArrayList.h b/dev/kernel/NewKit/ArrayList.h
index 1ea69fc5..d07e534c 100644
--- a/dev/kernel/NewKit/ArrayList.h
+++ b/dev/kernel/NewKit/ArrayList.h
@@ -1,6 +1,6 @@
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
@@ -8,56 +8,37 @@
 
 #include <NewKit/Defines.h>
 
-namespace Kernel
-{
-	template <typename T>
-	class ArrayList final
-	{
-	public:
-		explicit ArrayList(T* list, SizeT length)
-			: fList(reinterpret_cast<T>(list))
-		{
-		}
-
-		~ArrayList() = default;
-
-		ArrayList& operator=(const ArrayList&) = default;
-		ArrayList(const ArrayList&)			   = default;
-
-		T* Data()
-		{
-			return fList;
-		}
-
-		const T* CData()
-		{
-			return fList;
-		}
-
-		T& operator[](SizeT index) const
-		{
-			MUST_PASS(index < this->Count());
-			return fList[index];
-		}
-
-		operator bool()
-		{
-			return fList;
-		}
-
-		SizeT Count() const
-		{
-			return fLen;
-		}
-
-	private:
-		T*	  fList{nullptr};
-		SizeT fLen{0};
-	};
-
-	template <typename ValueType>
-	ArrayList<ValueType> make_list(ValueType val)
-	{
-		return ArrayList<ValueType>{val};
-	}
-} // namespace Kernel
+namespace Kernel {
+template <typename T>
+class ArrayList final {
+ public:
+  explicit ArrayList(T* list, SizeT length) : fList(reinterpret_cast<T>(list)) {}
+
+  ~ArrayList() = default;
+
+  ArrayList& operator=(const ArrayList&) = default;
+  ArrayList(const ArrayList&)            = default;
+
+  T* Data() { return fList; }
+
+  const T* CData() { return fList; }
+
+  T& operator[](SizeT index) const {
+    MUST_PASS(index < this->Count());
+    return fList[index];
+  }
+
+  operator bool() { return fList; }
+
+  SizeT Count() const { return fLen; }
+
+ private:
+  T*    fList{nullptr};
+  SizeT fLen{0};
+};
+
+template <typename ValueType>
+ArrayList<ValueType> make_list(ValueType val) {
+  return ArrayList<ValueType>{val};
+}
+}  // namespace Kernel
diff --git a/dev/kernel/NewKit/Atom.h b/dev/kernel/NewKit/Atom.h
index f9645fd8..4b23c933 100644
--- a/dev/kernel/NewKit/Atom.h
+++ b/dev/kernel/NewKit/Atom.h
@@ -1,47 +1,33 @@
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 #pragma once
 
 #include <NewKit/Defines.h>
 
-namespace Kernel
-{
-	template <typename T>
-	class Atom final
-	{
-	public:
-		explicit Atom() = default;
-		~Atom()			= default;
-
-	public:
-		Atom& operator=(const Atom&) = delete;
-		Atom(const Atom&)			 = delete;
-
-	public:
-		T operator[](Size bit)
-		{
-			return (fArrayOfAtoms & (1 << bit));
-		}
-
-		void operator|(Size bit)
-		{
-			fArrayOfAtoms |= (1 << bit);
-		}
-
-		friend Boolean operator==(Atom<T>& atomic, const T& idx)
-		{
-			return atomic[idx] == idx;
-		}
-
-		friend Boolean operator!=(Atom<T>& atomic, const T& idx)
-		{
-			return atomic[idx] == idx;
-		}
-
-	private:
-		T fArrayOfAtoms;
-	};
-} // namespace Kernel
+namespace Kernel {
+template <typename T>
+class Atom final {
+ public:
+  explicit Atom() = default;
+  ~Atom()         = default;
+
+ public:
+  Atom& operator=(const Atom&) = delete;
+  Atom(const Atom&)            = delete;
+
+ public:
+  T operator[](Size bit) { return (fArrayOfAtoms & (1 << bit)); }
+
+  void operator|(Size bit) { fArrayOfAtoms |= (1 << bit); }
+
+  friend Boolean operator==(Atom<T>& atomic, const T& idx) { return atomic[idx] == idx; }
+
+  friend Boolean operator!=(Atom<T>& atomic, const T& idx) { return atomic[idx] == idx; }
+
+ private:
+  T fArrayOfAtoms;
+};
+}  // namespace Kernel
diff --git a/dev/kernel/NewKit/Crc32.h b/dev/kernel/NewKit/Crc32.h
index b64a29a1..b6f33714 100644
--- a/dev/kernel/NewKit/Crc32.h
+++ b/dev/kernel/NewKit/Crc32.h
@@ -15,9 +15,8 @@
 
 #define kCrcCnt (256)
 
-namespace Kernel
-{
-	UInt32 ke_calculate_crc32(const Char* crc, Int32 len) noexcept;
-} // namespace Kernel
+namespace Kernel {
+UInt32 ke_calculate_crc32(const Char* crc, Int32 len) noexcept;
+}  // namespace Kernel
 
-#endif // !CRC32_H
+#endif  // !CRC32_H
diff --git a/dev/kernel/NewKit/CxxAbi.h b/dev/kernel/NewKit/CxxAbi.h
index 4bd3f662..8fb93bf8 100644
--- a/dev/kernel/NewKit/CxxAbi.h
+++ b/dev/kernel/NewKit/CxxAbi.h
@@ -1,6 +1,6 @@
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 #pragma once
@@ -11,18 +11,16 @@
 
 #define kAtExitMacDestructors (128)
 
-struct atexit_func_entry_t
-{
-	void (*destructor_func)();
-	void* obj_ptr;
-	void* dso_handle;
+struct atexit_func_entry_t {
+  void (*destructor_func)();
+  void* obj_ptr;
+  void* dso_handle;
 };
 
 typedef unsigned uarch_t;
 
-namespace cxxabiv1
-{
-	typedef void* __guard;
+namespace cxxabiv1 {
+typedef void* __guard;
 }
 
-#endif // __GNUC__
+#endif  // __GNUC__
diff --git a/dev/kernel/NewKit/Defines.h b/dev/kernel/NewKit/Defines.h
index 15b1d907..0d2f830f 100644
--- a/dev/kernel/NewKit/Defines.h
+++ b/dev/kernel/NewKit/Defines.h
@@ -1,6 +1,6 @@
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
@@ -28,174 +28,149 @@
 #endif
 
 /// @brief The **Kernel** namespace.
-namespace Kernel
-{
-	using voidPtr = void*;
-	using VoidPtr = void*;
-	using nullPtr = decltype(nullptr);
-	using NullPtr = decltype(nullptr);
-
-	using Int	  = int;
-	using Int32	  = int;
-	using UShort  = unsigned short;
-	using UInt16  = unsigned short;
-	using Short	  = short;
-	using Int16	  = short;
-	using UInt	  = unsigned int;
-	using UInt32  = unsigned int;
-	using Long	  = __INT64_TYPE__;
-	using Int64	  = __INT64_TYPE__;
-	using ULong	  = __UINT64_TYPE__;
-	using UInt64  = __UINT64_TYPE__;
-	using Boolean = bool;
-	using Bool	  = bool;
-	using Char	  = char;
-	using UChar	  = unsigned char;
-	using UInt8	  = unsigned char;
-
-	using SSize		= Int64;
-	using SSizeT	= Int64;
-	using Size		= __SIZE_TYPE__;
-	using SizeT		= __SIZE_TYPE__;
-	using IntPtr	= __INTPTR_TYPE__;
-	using UIntPtr	= __UINTPTR_TYPE__;
-	using IntFast	= __INT_FAST32_TYPE__;
-	using IntFast64 = __INT_FAST64_TYPE__;
-	using PtrDiff	= __PTRDIFF_TYPE__;
-
-	using SInt16 = Int16;
-	using SInt32 = Int32;
-	using SInt64 = Int64;
-
-	typedef UIntPtr* Ptr64;
-	typedef UInt32*	 Ptr32;
-	typedef UInt8*	 Ptr8;
-
-	using Utf8Char	= char8_t;
-	using Utf16Char = char16_t;
-	using WideChar	= wchar_t;
-	using Utf32Char = char32_t;
-
-	using LongDouble = long double;
-	using Double	 = double;
-	using Float		 = float;
-
-	typedef UInt32	PhysicalAddressKind;
-	typedef UIntPtr VirtualAddressKind;
-
-	using Void = void;
-
-	using Lba = UInt64;
-
-	using Char16 = char16_t;
-
-	enum class Endian : UInt8
-	{
-		kEndianInvalid,
-		kEndianBig,
-		kEndianLittle,
-		kEndianMixed,
-		kEndianCount
-	};
-
-	/// @brief Forward object.
-	/// @tparam Args the object type.
-	/// @param arg the object.
-	/// @return object's rvalue
-	template <typename Args>
-	inline Args&& forward(Args& arg)
-	{
-		return static_cast<Args&&>(arg);
-	}
-
-	/// @brief Move object.
-	/// @tparam Args the object type.
-	/// @param arg the object.
-	/// @return object's rvalue
-	template <typename Args>
-	inline Args&& move(Args&& arg)
-	{
-		return static_cast<Args&&>(arg);
-	}
-
-	/// @brief Encoding interface, used as a proxy to convert T to Char*
-	/// Used to cast A to B or B to A.
-	class ICodec
-	{
-	public:
-		explicit ICodec() = default;
-		virtual ~ICodec() = default;
-
-		ICodec& operator=(const ICodec&) = default;
-		ICodec(const ICodec&)			 = default;
-
-	public:
-		/// @brief Convert type to bytes.
-		/// @tparam T the type.
-		/// @param type (a1) the data.
-		/// @return a1 as Char*
-		template <typename T>
-		const Char* AsBytes(T type) noexcept
-		{
-			NE_UNUSED(type);
-			return nullptr;
-		}
-
-		/// @brief Construct from type to class.
-		/// @tparam T the type to convert.
-		/// @param type (a1) the data.
-		/// @return a1 as Char*
-		template <typename OutputClass, typename FactoryClass>
-		OutputClass* Construct(Char* type) noexcept
-		{
-			FactoryClass class_fac;
-			return class_fac.template From<OutputClass>(type);
-		}
-
-		/// @brief Convert T class to Y class.
-		/// @tparam T the class type of type.
-		/// @tparam Y the result class.
-		/// @param type the class to cast.
-		/// @return the class as Y.
-		template <typename T, typename Y>
-		Y As(T type) noexcept
-		{
-			if (type.template IsSerializable())
-			{
-				return reinterpret_cast<Char*>(type);
-			}
-
-			return type.template As<Y>();
-		}
-	};
-
-	/// \brief Scheduler interface, represents a scheduler object.
-	/// @note This is used to schedule tasks, such as threads, drivers, user threads, etc.
-	class ISchedulable
-	{
-	public:
-		explicit ISchedulable() = default;
-		virtual ~ISchedulable() = default;
-
-		ISchedulable& operator=(const ISchedulable&) = default;
-		ISchedulable(const ISchedulable&)			 = default;
-
-		/// @brief Is this object only accepting user tasks?
-		virtual Bool IsUser()
-		{
-			return NO;
-		}
-
-		/// @brief Is this object only accepting kernel tasks?
-		virtual Bool IsKernel()
-		{
-			return NO;
-		}
-
-		/// @brief Is this object offloading to another CPU?
-		virtual Bool HasMP()
-		{
-			return NO;
-		}
-	};
-} // namespace Kernel
+namespace Kernel {
+using voidPtr = void*;
+using VoidPtr = void*;
+using nullPtr = decltype(nullptr);
+using NullPtr = decltype(nullptr);
+
+using Int     = int;
+using Int32   = int;
+using UShort  = unsigned short;
+using UInt16  = unsigned short;
+using Short   = short;
+using Int16   = short;
+using UInt    = unsigned int;
+using UInt32  = unsigned int;
+using Long    = __INT64_TYPE__;
+using Int64   = __INT64_TYPE__;
+using ULong   = __UINT64_TYPE__;
+using UInt64  = __UINT64_TYPE__;
+using Boolean = bool;
+using Bool    = bool;
+using Char    = char;
+using UChar   = unsigned char;
+using UInt8   = unsigned char;
+
+using SSize     = Int64;
+using SSizeT    = Int64;
+using Size      = __SIZE_TYPE__;
+using SizeT     = __SIZE_TYPE__;
+using IntPtr    = __INTPTR_TYPE__;
+using UIntPtr   = __UINTPTR_TYPE__;
+using IntFast   = __INT_FAST32_TYPE__;
+using IntFast64 = __INT_FAST64_TYPE__;
+using PtrDiff   = __PTRDIFF_TYPE__;
+
+using SInt16 = Int16;
+using SInt32 = Int32;
+using SInt64 = Int64;
+
+typedef UIntPtr* Ptr64;
+typedef UInt32*  Ptr32;
+typedef UInt8*   Ptr8;
+
+using Utf8Char  = char8_t;
+using Utf16Char = char16_t;
+using WideChar  = wchar_t;
+using Utf32Char = char32_t;
+
+using LongDouble = long double;
+using Double     = double;
+using Float      = float;
+
+typedef UInt32  PhysicalAddressKind;
+typedef UIntPtr VirtualAddressKind;
+
+using Void = void;
+
+using Lba = UInt64;
+
+using Char16 = char16_t;
+
+enum class Endian : UInt8 { kEndianInvalid, kEndianBig, kEndianLittle, kEndianMixed, kEndianCount };
+
+/// @brief Forward object.
+/// @tparam Args the object type.
+/// @param arg the object.
+/// @return object's rvalue
+template <typename Args>
+inline Args&& forward(Args& arg) {
+  return static_cast<Args&&>(arg);
+}
+
+/// @brief Move object.
+/// @tparam Args the object type.
+/// @param arg the object.
+/// @return object's rvalue
+template <typename Args>
+inline Args&& move(Args&& arg) {
+  return static_cast<Args&&>(arg);
+}
+
+/// @brief Encoding interface, used as a proxy to convert T to Char*
+/// Used to cast A to B or B to A.
+class ICodec {
+ public:
+  explicit ICodec() = default;
+  virtual ~ICodec() = default;
+
+  ICodec& operator=(const ICodec&) = default;
+  ICodec(const ICodec&)            = default;
+
+ public:
+  /// @brief Convert type to bytes.
+  /// @tparam T the type.
+  /// @param type (a1) the data.
+  /// @return a1 as Char*
+  template <typename T>
+  const Char* AsBytes(T type) noexcept {
+    NE_UNUSED(type);
+    return nullptr;
+  }
+
+  /// @brief Construct from type to class.
+  /// @tparam T the type to convert.
+  /// @param type (a1) the data.
+  /// @return a1 as Char*
+  template <typename OutputClass, typename FactoryClass>
+  OutputClass* Construct(Char* type) noexcept {
+    FactoryClass class_fac;
+    return class_fac.template From<OutputClass>(type);
+  }
+
+  /// @brief Convert T class to Y class.
+  /// @tparam T the class type of type.
+  /// @tparam Y the result class.
+  /// @param type the class to cast.
+  /// @return the class as Y.
+  template <typename T, typename Y>
+  Y As(T type) noexcept {
+    if (type.template IsSerializable()) {
+      return reinterpret_cast<Char*>(type);
+    }
+
+    return type.template As<Y>();
+  }
+};
+
+/// \brief Scheduler interface, represents a scheduler object.
+/// @note This is used to schedule tasks, such as threads, drivers, user threads, etc.
+class ISchedulable {
+ public:
+  explicit ISchedulable() = default;
+  virtual ~ISchedulable() = default;
+
+  ISchedulable& operator=(const ISchedulable&) = default;
+  ISchedulable(const ISchedulable&)            = default;
+
+  /// @brief Is this object only accepting user tasks?
+  virtual Bool IsUser() { return NO; }
+
+  /// @brief Is this object only accepting kernel tasks?
+  virtual Bool IsKernel() { return NO; }
+
+  /// @brief Is this object offloading to another CPU?
+  virtual Bool HasMP() { return NO; }
+};
+}  // namespace Kernel
diff --git a/dev/kernel/NewKit/ErrorOr.h b/dev/kernel/NewKit/ErrorOr.h
index 0342a0db..f2de3432 100644
--- a/dev/kernel/NewKit/ErrorOr.h
+++ b/dev/kernel/NewKit/ErrorOr.h
@@ -12,71 +12,45 @@
 #include <NewKit/Defines.h>
 #include <NewKit/Ref.h>
 
-namespace Kernel
-{
-	using ErrorT = UInt;
-
-	template <typename T>
-	class ErrorOr final
-	{
-	public:
-		ErrorOr()  = default;
-		~ErrorOr() = default;
-
-	public:
-		explicit ErrorOr(Int32 err)
-			: mId(err)
-		{
-		}
-
-		explicit ErrorOr(nullPtr Null)
-		{
-		}
-
-		explicit ErrorOr(T* Class)
-			: mRef(Class)
-		{
-		}
-
-		explicit ErrorOr(T Class)
-			: mRef(Class)
-		{
-		}
-
-		ErrorOr& operator=(const ErrorOr&) = default;
-		ErrorOr(const ErrorOr&)			   = default;
-
-		ErrorOr& operator=(const Ref<T>& refErr)
-		{
-			mRef = refErr;
-			return *this;
-		}
-
-		Ref<T>& Leak()
-		{
-			return mRef;
-		}
-
-		Int32 Error()
-		{
-			return mId;
-		}
-
-		operator bool()
-		{
-			return mRef;
-		}
-
-		BOOL HasError()
-		{
-			return this->mId > 0;
-		}
-
-	private:
-		Ref<T> mRef;
-		UInt32 mId{0};
-	};
-
-	using ErrorOrAny = ErrorOr<voidPtr>;
-
-} // namespace Kernel
+namespace Kernel {
+using ErrorT = UInt;
+
+template <typename T>
+class ErrorOr final {
+ public:
+  ErrorOr()  = default;
+  ~ErrorOr() = default;
+
+ public:
+  explicit ErrorOr(Int32 err) : mId(err) {}
+
+  explicit ErrorOr(nullPtr Null) {}
+
+  explicit ErrorOr(T* Class) : mRef(Class) {}
+
+  explicit ErrorOr(T Class) : mRef(Class) {}
+
+  ErrorOr& operator=(const ErrorOr&) = default;
+  ErrorOr(const ErrorOr&)            = default;
+
+  ErrorOr& operator=(const Ref<T>& refErr) {
+    mRef = refErr;
+    return *this;
+  }
+
+  Ref<T>& Leak() { return mRef; }
+
+  Int32 Error() { return mId; }
+
+  operator bool() { return mRef; }
+
+  BOOL HasError() { return this->mId > 0; }
+
+ private:
+  Ref<T> mRef;
+  UInt32 mId{0};
+};
+
+using ErrorOrAny = ErrorOr<voidPtr>;
+
+}  // namespace Kernel
diff --git a/dev/kernel/NewKit/Function.h b/dev/kernel/NewKit/Function.h
index 9fa218af..e0af5842 100644
--- a/dev/kernel/NewKit/Function.h
+++ b/dev/kernel/NewKit/Function.h
@@ -3,51 +3,38 @@
 
 #include <NewKit/Defines.h>
 
-namespace Kernel
-{
-	template <typename T, typename... Args>
-	class Function final
-	{
-	public:
-		Function() = default;
-
-	public:
-		explicit Function(T (*Fn)(Args... args))
-			: fFn(Fn)
-		{
-		}
-
-		~Function() = default;
-
-		Function& operator=(const Function&) = default;
-		Function(const Function&)			 = default;
-
-		template <typename... XArgs>
-		T operator()(Args... args)
-		{
-			return fFn(args...);
-		}
-
-		template <typename... XArgs>
-		T Call(Args... args)
-		{
-			return fFn(args...);
-		}
-
-		operator bool()
-		{
-			return fFn;
-		}
-
-		bool operator!()
-		{
-			return !fFn;
-		}
-
-	private:
-		T(*fFn)
-		(Args... args);
-	};
-} // namespace Kernel
-
-#endif // !_INC_FUNCTION_H__
+namespace Kernel {
+template <typename T, typename... Args>
+class Function final {
+ public:
+  Function() = default;
+
+ public:
+  explicit Function(T (*Fn)(Args... args)) : fFn(Fn) {}
+
+  ~Function() = default;
+
+  Function& operator=(const Function&) = default;
+  Function(const Function&)            = default;
+
+  template <typename... XArgs>
+  T operator()(Args... args) {
+    return fFn(args...);
+  }
+
+  template <typename... XArgs>
+  T Call(Args... args) {
+    return fFn(args...);
+  }
+
+  operator bool() { return fFn; }
+
+  bool operator!() { return !fFn; }
+
+ private:
+  T(*fFn)
+  (Args... args);
+};
+}  // namespace Kernel
+
+#endif  // !_INC_FUNCTION_H__
diff --git a/dev/kernel/NewKit/Json.h b/dev/kernel/NewKit/Json.h
index 8520dd71..6af71b72 100644
--- a/dev/kernel/NewKit/Json.h
+++ b/dev/kernel/NewKit/Json.h
@@ -1,7 +1,7 @@
 
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
@@ -11,155 +11,119 @@
 
 #include <CompilerKit/CompilerKit.h>
 #include <NewKit/Defines.h>
-#include <NewKit/Stream.h>
 #include <NewKit/KString.h>
+#include <NewKit/Stream.h>
 #include <NewKit/Utils.h>
 
-#define kJSONMaxLen	 (8196)
-#define kJSONLen	 (256)
+#define kJSONMaxLen (8196)
+#define kJSONLen (256)
 #define kJSONNullArr "[]"
 #define kJSONNullObj "{}"
 
-namespace Kernel
-{
-	/// @brief JavaScript object class
-	class Json final
-	{
-	public:
-		explicit Json()
-		{
-			auto	len = kJSONMaxLen;
-			KString key = KString(len);
-			key += kJSONNullObj;
-
-			this->AsKey()	= key;
-			this->AsValue() = key;
-		}
-
-		explicit Json(SizeT lhsLen, SizeT rhsLen)
-			: fKey(lhsLen), fValue(rhsLen)
-		{
-		}
-
-		~Json() = default;
-
-		NE_COPY_DEFAULT(Json)
-
-		Bool& IsUndefined()
-		{
-			return fUndefined;
-		}
-
-	private:
-		Bool	fUndefined; // is this instance undefined?
-		KString fKey;
-		KString fValue;
-
-	public:
-		/// @brief returns the key of the json
-		/// @return the key as string view.
-		KString& AsKey()
-		{
-			return fKey;
-		}
-
-		/// @brief returns the value of the json.
-		/// @return the key as string view.
-		KString& AsValue()
-		{
-			return fValue;
-		}
-
-		static Json kNull;
-	};
-
-	/// @brief Json stream reader helper.
-	struct JsonStreamReader final
-	{
-		STATIC Json In(const Char* full_array)
-		{
-			auto	start_val	= '{';
-			auto	end_val		= '}';
-			Boolean probe_value = false;
-
-			if (full_array[0] != start_val)
-			{
-				if (full_array[0] != '[')
-					return Json::kNull;
-
-				start_val = '[';
-				end_val	  = ']';
-
-				probe_value = true;
-			}
-
-			SizeT len = rt_string_len(full_array);
-
-			SizeT key_len	= 0;
-			SizeT value_len = 0;
-
-			Json type(kJSONMaxLen, kJSONMaxLen);
-
-			for (SizeT i = 1; i < len; ++i)
-			{
-				if (full_array[i] == '\r' ||
-					full_array[i] == '\n')
-					continue;
-
-				if (probe_value)
-				{
-					if (full_array[i] == end_val ||
-						full_array[i] == ',')
-					{
-						probe_value = false;
-
-						++value_len;
-					}
-					else
-					{
-						if (full_array[i] == '\'')
-						{
-							type.AsValue().Data()[value_len] = 0;
-							break;
-						}
-
-						type.AsValue().Data()[value_len] = full_array[i];
-
-						++value_len;
-					}
-				}
-				else
-				{
-					if (start_val == '[')
-						continue;
-
-					if (full_array[i] == ':')
-					{
-						type.AsKey().Data()[key_len] = 0;
-						++key_len;
-
-						++i;
-
-						while (full_array[i] == ' ' ||
-							   full_array[i] == '\t')
-							++i;
-
-						probe_value = true;
-					}
-					else
-					{
-						type.AsKey().Data()[key_len] = full_array[i];
-
-						++key_len;
-					}
-				}
-			}
-
-			type.AsValue().Data()[value_len] = 0;
-
-			return type;
-		}
-	};
-
-	using JsonStream = Stream<JsonStreamReader, Json>;
-} // namespace Kernel
+namespace Kernel {
+/// @brief JavaScript object class
+class Json final {
+ public:
+  explicit Json() {
+    auto    len = kJSONMaxLen;
+    KString key = KString(len);
+    key += kJSONNullObj;
+
+    this->AsKey()   = key;
+    this->AsValue() = key;
+  }
+
+  explicit Json(SizeT lhsLen, SizeT rhsLen) : fKey(lhsLen), fValue(rhsLen) {}
+
+  ~Json() = default;
+
+  NE_COPY_DEFAULT(Json)
+
+  Bool& IsUndefined() { return fUndefined; }
+
+ private:
+  Bool    fUndefined;  // is this instance undefined?
+  KString fKey;
+  KString fValue;
+
+ public:
+  /// @brief returns the key of the json
+  /// @return the key as string view.
+  KString& AsKey() { return fKey; }
+
+  /// @brief returns the value of the json.
+  /// @return the key as string view.
+  KString& AsValue() { return fValue; }
+
+  static Json kNull;
+};
+
+/// @brief Json stream reader helper.
+struct JsonStreamReader final {
+  STATIC Json In(const Char* full_array) {
+    auto    start_val   = '{';
+    auto    end_val     = '}';
+    Boolean probe_value = false;
+
+    if (full_array[0] != start_val) {
+      if (full_array[0] != '[') return Json::kNull;
+
+      start_val = '[';
+      end_val   = ']';
+
+      probe_value = true;
+    }
+
+    SizeT len = rt_string_len(full_array);
+
+    SizeT key_len   = 0;
+    SizeT value_len = 0;
+
+    Json type(kJSONMaxLen, kJSONMaxLen);
+
+    for (SizeT i = 1; i < len; ++i) {
+      if (full_array[i] == '\r' || full_array[i] == '\n') continue;
+
+      if (probe_value) {
+        if (full_array[i] == end_val || full_array[i] == ',') {
+          probe_value = false;
+
+          ++value_len;
+        } else {
+          if (full_array[i] == '\'') {
+            type.AsValue().Data()[value_len] = 0;
+            break;
+          }
+
+          type.AsValue().Data()[value_len] = full_array[i];
+
+          ++value_len;
+        }
+      } else {
+        if (start_val == '[') continue;
+
+        if (full_array[i] == ':') {
+          type.AsKey().Data()[key_len] = 0;
+          ++key_len;
+
+          ++i;
+
+          while (full_array[i] == ' ' || full_array[i] == '\t') ++i;
+
+          probe_value = true;
+        } else {
+          type.AsKey().Data()[key_len] = full_array[i];
+
+          ++key_len;
+        }
+      }
+    }
+
+    type.AsValue().Data()[value_len] = 0;
+
+    return type;
+  }
+};
+
+using JsonStream = Stream<JsonStreamReader, Json>;
+}  // namespace Kernel
diff --git a/dev/kernel/NewKit/KString.h b/dev/kernel/NewKit/KString.h
index e182fd30..133fe945 100644
--- a/dev/kernel/NewKit/KString.h
+++ b/dev/kernel/NewKit/KString.h
@@ -1,6 +1,6 @@
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
@@ -9,87 +9,73 @@
 #include <CompilerKit/CompilerKit.h>
 #include <NewKit/Defines.h>
 #include <NewKit/ErrorOr.h>
-#include <NewKit/Utils.h>
 #include <NewKit/KernelPanic.h>
+#include <NewKit/Utils.h>
 
 #define cMinimumStringSize 8196
 
-namespace Kernel
-{
-	/// @brief Kernel string class, not dynamic.
-	class KString final
-	{
-	public:
-		explicit KString()
-		{
-			fDataSz = cMinimumStringSize;
-
-			fData = new Char[fDataSz];
-			MUST_PASS(fData);
-
-			rt_set_memory(fData, 0, fDataSz);
-		}
-
-		explicit KString(SizeT Sz)
-			: fDataSz(Sz)
-		{
-			MUST_PASS(Sz > 1);
-
-			fData = new Char[Sz];
-			MUST_PASS(fData);
-
-			rt_set_memory(fData, 0, Sz);
-		}
-
-		~KString()
-		{
-			if (fData)
-			{
-				delete[] fData;
-				fData = nullptr;
-			}
-		}
-
-		NE_COPY_DEFAULT(KString)
-
-		Char*		Data();
-		const Char* CData() const;
-		Size		Length() const;
-
-		bool operator==(const Char* rhs) const;
-		bool operator!=(const Char* rhs) const;
-
-		bool operator==(const KString& rhs) const;
-		bool operator!=(const KString& rhs) const;
-
-		KString& operator+=(const Char* rhs);
-		KString& operator+=(const KString& rhs);
-
-		operator bool()
-		{
-			return fData;
-		}
-
-		bool operator!()
-		{
-			return fData;
-		}
-
-	private:
-		Char* fData{nullptr};
-		Size  fDataSz{0};
-		Size  fCur{0};
-
-		friend class KStringBuilder;
-	};
-
-	struct KStringBuilder final
-	{
-		static ErrorOr<KString> Construct(const Char* data);
-		static const Char*		FromBool(const Char* fmt, bool n);
-		static const Char*		Format(const Char* fmt, const Char* from);
-		static bool				Equals(const Char* lhs, const Char* rhs);
-		static bool				Equals(const Utf16Char* lhs, const Utf16Char* rhs);
-		static bool				Equals(const WideChar* lhs, const WideChar* rhs);
-	};
-} // namespace Kernel
+namespace Kernel {
+/// @brief Kernel string class, not dynamic.
+class KString final {
+ public:
+  explicit KString() {
+    fDataSz = cMinimumStringSize;
+
+    fData = new Char[fDataSz];
+    MUST_PASS(fData);
+
+    rt_set_memory(fData, 0, fDataSz);
+  }
+
+  explicit KString(SizeT Sz) : fDataSz(Sz) {
+    MUST_PASS(Sz > 1);
+
+    fData = new Char[Sz];
+    MUST_PASS(fData);
+
+    rt_set_memory(fData, 0, Sz);
+  }
+
+  ~KString() {
+    if (fData) {
+      delete[] fData;
+      fData = nullptr;
+    }
+  }
+
+  NE_COPY_DEFAULT(KString)
+
+  Char*       Data();
+  const Char* CData() const;
+  Size        Length() const;
+
+  bool operator==(const Char* rhs) const;
+  bool operator!=(const Char* rhs) const;
+
+  bool operator==(const KString& rhs) const;
+  bool operator!=(const KString& rhs) const;
+
+  KString& operator+=(const Char* rhs);
+  KString& operator+=(const KString& rhs);
+
+  operator bool() { return fData; }
+
+  bool operator!() { return fData; }
+
+ private:
+  Char* fData{nullptr};
+  Size  fDataSz{0};
+  Size  fCur{0};
+
+  friend class KStringBuilder;
+};
+
+struct KStringBuilder final {
+  static ErrorOr<KString> Construct(const Char* data);
+  static const Char*      FromBool(const Char* fmt, bool n);
+  static const Char*      Format(const Char* fmt, const Char* from);
+  static bool             Equals(const Char* lhs, const Char* rhs);
+  static bool             Equals(const Utf16Char* lhs, const Utf16Char* rhs);
+  static bool             Equals(const WideChar* lhs, const WideChar* rhs);
+};
+}  // namespace Kernel
diff --git a/dev/kernel/NewKit/KernelPanic.h b/dev/kernel/NewKit/KernelPanic.h
index d630e6b4..6d7f4d23 100644
--- a/dev/kernel/NewKit/KernelPanic.h
+++ b/dev/kernel/NewKit/KernelPanic.h
@@ -1,7 +1,7 @@
 
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
@@ -9,9 +9,8 @@
 
 #include <NewKit/Defines.h>
 
-namespace Kernel
-{
-	void ke_runtime_check(bool expr, const Char* file, const Char* line);
+namespace Kernel {
+void ke_runtime_check(bool expr, const Char* file, const Char* line);
 }
 
 #define MUST_PASS_COMPILER(EXPR, MSG) static_assert(EXPR, MSG)
@@ -20,14 +19,13 @@ namespace Kernel
 #undef TRY
 #endif
 
-#define TRY(X)             \
-	{                      \
-		auto fn = X;       \
-		if ((fn()) == NO)  \
-		{                  \
-			MUST_PASS(NO); \
-		}                  \
-	}
+#define TRY(X)          \
+  {                     \
+    auto fn = X;        \
+    if ((fn()) == NO) { \
+      MUST_PASS(NO);    \
+    }                   \
+  }
 
 #ifdef __MUST_PASS
 #undef __MUST_PASS
@@ -37,37 +35,35 @@ namespace Kernel
 
 #ifdef __DEBUG__
 #define MUST_PASS(EXPR) __MUST_PASS((EXPR), __FILE__, __LINE__)
-#define assert(EXPR)	MUST_PASS(EXPR)
+#define assert(EXPR) MUST_PASS(EXPR)
 #else
 #define MUST_PASS(EXPR) (Kernel::Void)(EXPR)
-#define assert(EXPR)	(Kernel::Void)(EXPR)
+#define assert(EXPR) (Kernel::Void)(EXPR)
 #endif
 
-enum RUNTIME_CHECK
-{
-	RUNTIME_CHECK_FAILED = 1111,
-	RUNTIME_CHECK_POINTER,
-	RUNTIME_CHECK_EXPRESSION,
-	RUNTIME_CHECK_FILE,
-	RUNTIME_CHECK_IPC,
-	RUNTIME_CHECK_TLS,
-	RUNTIME_CHECK_HANDSHAKE,
-	RUNTIME_CHECK_ACPI,
-	RUNTIME_CHECK_INVALID_PRIVILEGE,
-	RUNTIME_CHECK_PROCESS,
-	RUNTIME_CHECK_BAD_BEHAVIOR,
-	RUNTIME_CHECK_BOOTSTRAP,
-	RUNTIME_CHECK_UNEXCPECTED,
-	RUNTIME_CHECK_FILESYSTEM,
-	RUNTIME_CHECK_VIRTUAL_OUT_OF_MEM,
-	RUNTIME_CHECK_PAGE,
-	RUNTIME_CHECK_INVALID,
-	RUNTIME_CHECK_COUNT,
+enum RUNTIME_CHECK {
+  RUNTIME_CHECK_FAILED = 1111,
+  RUNTIME_CHECK_POINTER,
+  RUNTIME_CHECK_EXPRESSION,
+  RUNTIME_CHECK_FILE,
+  RUNTIME_CHECK_IPC,
+  RUNTIME_CHECK_TLS,
+  RUNTIME_CHECK_HANDSHAKE,
+  RUNTIME_CHECK_ACPI,
+  RUNTIME_CHECK_INVALID_PRIVILEGE,
+  RUNTIME_CHECK_PROCESS,
+  RUNTIME_CHECK_BAD_BEHAVIOR,
+  RUNTIME_CHECK_BOOTSTRAP,
+  RUNTIME_CHECK_UNEXCPECTED,
+  RUNTIME_CHECK_FILESYSTEM,
+  RUNTIME_CHECK_VIRTUAL_OUT_OF_MEM,
+  RUNTIME_CHECK_PAGE,
+  RUNTIME_CHECK_INVALID,
+  RUNTIME_CHECK_COUNT,
 };
 
 typedef enum RUNTIME_CHECK RTL_RUNTIME_CHECK;
 
-namespace Kernel
-{
-	void ke_panic(const Int32& id, const Char* message = nullptr);
-} // namespace Kernel
+namespace Kernel {
+void ke_panic(const Int32& id, const Char* message = nullptr);
+}  // namespace Kernel
diff --git a/dev/kernel/NewKit/Macros.h b/dev/kernel/NewKit/Macros.h
index 83dbc7b5..b89f5d67 100644
--- a/dev/kernel/NewKit/Macros.h
+++ b/dev/kernel/NewKit/Macros.h
@@ -1,6 +1,6 @@
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
@@ -16,52 +16,51 @@
 #endif
 
 #ifndef kib_cast
-#define kib_cast(X) (Kernel::UInt64)((X)*1024)
+#define kib_cast(X) (Kernel::UInt64)((X) * 1024)
 #endif
 
 #ifndef MIB
-#define MIB(X) (Kernel::UInt64)((Kernel::UInt64)KIB(X) / 1024)
+#define MIB(X) (Kernel::UInt64)((Kernel::UInt64) KIB(X) / 1024)
 #endif
 
 #ifndef mib_cast
-#define mib_cast(X) (Kernel::UInt64)((Kernel::UInt64)kib_cast(X) * 1024)
+#define mib_cast(X) (Kernel::UInt64)((Kernel::UInt64) kib_cast(X) * 1024)
 #endif
 
 #ifndef GIB
-#define GIB(X) (Kernel::UInt64)((Kernel::UInt64)MIB(X) / 1024)
+#define GIB(X) (Kernel::UInt64)((Kernel::UInt64) MIB(X) / 1024)
 #endif
 
 #ifndef gib_cast
-#define gib_cast(X) (Kernel::UInt64)((Kernel::UInt64)mib_cast(X) * 1024)
+#define gib_cast(X) (Kernel::UInt64)((Kernel::UInt64) mib_cast(X) * 1024)
 #endif
 
 #ifndef TIB
-#define TIB(X) (Kernel::UInt64)((Kernel::UInt64)GIB(X) / 1024)
+#define TIB(X) (Kernel::UInt64)((Kernel::UInt64) GIB(X) / 1024)
 #endif
 
 #ifndef tib_cast
-#define tib_cast(X) ((Kernel::UInt64)gib_cast(X) * 1024)
+#define tib_cast(X) ((Kernel::UInt64) gib_cast(X) * 1024)
 #endif
 
 #ifndef ARRAY_SIZE
-#define ARRAY_SIZE(a)              \
-	(((sizeof(a) / sizeof(*(a))) / \
-	  (static_cast<Kernel::Size>(!(sizeof(a) % sizeof(*(a)))))))
+#define ARRAY_SIZE(a) \
+  (((sizeof(a) / sizeof(*(a))) / (static_cast<Kernel::Size>(!(sizeof(a) % sizeof(*(a)))))))
 #endif
 
 #define DEPRECATED ATTRIBUTE(deprecated)
 
 #ifndef ALIGN
 #define ALIGN(X) __attribute__((aligned(X)))
-#endif // #ifndef ALIGN
+#endif  // #ifndef ALIGN
 
 #ifndef ATTRIBUTE
 #define ATTRIBUTE(...) __attribute__((__VA_ARGS__))
-#endif // #ifndef ATTRIBUTE
+#endif  // #ifndef ATTRIBUTE
 
 #ifndef __NE_VER__
 #define __NE_VER__ (2024)
-#endif // !__NE_VER__
+#endif  // !__NE_VER__
 
 #ifndef EXTERN
 #define EXTERN extern
@@ -72,21 +71,17 @@
 #endif
 
 #ifndef MAKE_ENUM
-#define MAKE_ENUM(NAME) \
-	enum NAME           \
-	{
+#define MAKE_ENUM(NAME) enum NAME {
 #endif
 
 #ifndef END_ENUM
 #define END_ENUM() \
-	}              \
-	;
+  }                \
+  ;
 #endif
 
 #ifndef MAKE_STRING_ENUM
-#define MAKE_STRING_ENUM(NAME) \
-	namespace NAME             \
-	{
+#define MAKE_STRING_ENUM(NAME) namespace NAME {
 #endif
 
 #ifndef ENUM_STRING
@@ -99,18 +94,18 @@
 
 #ifndef RTL_ALLOCA
 #define RTL_ALLOCA(sz) __builtin_alloca(sz)
-#endif // #ifndef RTL_ALLOCA
+#endif  // #ifndef RTL_ALLOCA
 
 #ifndef CANT_REACH
 #define CANT_REACH() __builtin_unreachable()
 #endif
 
 #define kInvalidAddress 0xFBFBFBFBFBFBFBFB
-#define kBadAddress		0x0000000000000000
-#define kMaxAddr		0xFFFFFFFFFFFFFFFF
-#define kPathLen		0x100
+#define kBadAddress 0x0000000000000000
+#define kMaxAddr 0xFFFFFFFFFFFFFFFF
+#define kPathLen 0x100
 
-#define PACKED	ATTRIBUTE(packed)
+#define PACKED ATTRIBUTE(packed)
 #define NO_EXEC ATTRIBUTE(noexec)
 
 #define EXTERN extern
@@ -119,36 +114,35 @@
 #define CONST const
 
 #define STRINGIFY(X) #X
-#define NE_UNUSED(X) ((Kernel::Void)X)
+#define NE_UNUSED(X) ((Kernel::Void) X)
 
 #ifndef RGB
 #define RGB(R, G, B) ((Kernel::UInt32)((0xFF << 24) | ((R) << 16) | ((G) << 8) | (B)))
-#endif // !RGB
+#endif  // !RGB
 
 #ifdef __NE_AMD64__
 #define dbg_break_point() asm volatile("int $3")
 #else
-#define dbg_break_point() ((void)0)
+#define dbg_break_point() ((void) 0)
 #endif
 
-#define RTL_ENDIAN(address, value)                              \
-	(((reinterpret_cast<Kernel::Char*>(address)[0]) == (value)) \
-		 ? (Kernel::Endian::kEndianBig)                         \
-		 : (Kernel::Endian::kEndianLittle))
+#define RTL_ENDIAN(address, value)                                                           \
+  (((reinterpret_cast<Kernel::Char*>(address)[0]) == (value)) ? (Kernel::Endian::kEndianBig) \
+                                                              : (Kernel::Endian::kEndianLittle))
 
 #define Yes true
-#define No	false
+#define No false
 
 #define YES true
-#define NO	false
+#define NO false
 
-#define TRUE  true
+#define TRUE true
 #define FALSE false
 
 #define BOOL Kernel::Boolean
 
 #ifdef rtl_init_object
 #undef rtl_init_object
-#endif // ifdef rtl_init_object
+#endif  // ifdef rtl_init_object
 
 #define rtl_init_object(OBJ, TYPE, ...) TYPE OBJ = TYPE(__VA_ARGS__)
diff --git a/dev/kernel/NewKit/MutableArray.h b/dev/kernel/NewKit/MutableArray.h
index 40d61495..08c8cbf5 100644
--- a/dev/kernel/NewKit/MutableArray.h
+++ b/dev/kernel/NewKit/MutableArray.h
@@ -1,6 +1,6 @@
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 #pragma once
@@ -9,231 +9,195 @@
 #include <NewKit/Array.h>
 #include <NewKit/Defines.h>
 
-#define TRY_FIND_NODE(NAME, NODE)  \
-	auto* NAME = NODE;             \
-	while (NAME)                   \
-	{                              \
-		if (NAME->fIndex == Index) \
-			return NAME->fVal;     \
-		NAME = NAME->fNext;        \
-	}
-
-#define TRY_FIND_NODE2(NAME, NODE)     \
-	auto* NAME = NODE;                 \
-	while (NAME)                       \
-	{                                  \
-		if (NAME->fIndex == Index)     \
-			return Ref<T>{NAME->fVal}; \
-		NAME = NAME->fNext;            \
-	}
+#define TRY_FIND_NODE(NAME, NODE)                 \
+  auto* NAME = NODE;                              \
+  while (NAME) {                                  \
+    if (NAME->fIndex == Index) return NAME->fVal; \
+    NAME = NAME->fNext;                           \
+  }
+
+#define TRY_FIND_NODE2(NAME, NODE)                        \
+  auto* NAME = NODE;                                      \
+  while (NAME) {                                          \
+    if (NAME->fIndex == Index) return Ref<T>{NAME->fVal}; \
+    NAME = NAME->fNext;                                   \
+  }
 
 #define TRY_REMOVE_NODE(NODE)          \
-	if (NODE && NODE->fIndex == Index) \
-	{                                  \
-		NODE->fUsed	 = false;          \
-		NODE->fIndex = 0;              \
+  if (NODE && NODE->fIndex == Index) { \
+    NODE->fUsed  = false;              \
+    NODE->fIndex = 0;                  \
                                        \
-		return true;                   \
-	}
+    return true;                       \
+  }
 
 // FIXME: this is a shitty algorithm, which is consumer hungry.
 // Remove and occurences of that, and remove that class.
-namespace Kernel
-{
-	template <typename T>
-	class MutableArray;
-
-	template <typename T, T _PlaceHolderValue>
-	class NullableMutableArray;
-
-	template <typename T>
-	class MutableLinkedList
-	{
-	public:
-		T		fVal;
-		SizeT	fIndex{0};
-		Boolean fUsed{false};
-
-		MutableLinkedList* fPrev{nullptr};
-		MutableLinkedList* fNext{nullptr};
-	};
-
-	template <typename T, T _PlaceHolderValue>
-	class NullableMutableArray
-	{
-	public:
-		// explicit this.
-		explicit NullableMutableArray()
-			: fFirstNode(new MutableLinkedList<T>())
-		{
-		}
-
-		/*
-		 * We free all the nodes allocated by the array
-		 * and store the next one inside "NextIt"
-		 */
-
-		virtual ~NullableMutableArray()
-		{
-			auto*				  It	 = fFirstNode;
-			MutableLinkedList<T>* NextIt = nullptr;
-
-			while (It)
-			{
-				NextIt = It->fNext;
-				delete It;
-
-				It = NextIt;
-			}
-		}
-
-		NullableMutableArray& operator=(const NullableMutableArray&) = default;
-		NullableMutableArray(const NullableMutableArray&)			 = default;
-
-		operator bool()
-		{
-			return Count() > 1;
-		}
-
-	public:
-		T operator[](SizeT Index) const
-		{
-			TRY_FIND_NODE(first, fFirstNode);
-			TRY_FIND_NODE(last, fLastNode);
-
-			return _PlaceHolderValue;
-		}
-
-		SizeT Count() const
-		{
-			return fNodeCount;
-		}
-
-	public:
-		Boolean Remove(SizeT Index)
-		{
-			TRY_REMOVE_NODE(fFirstNode);
-			TRY_REMOVE_NODE(fLastNode);
-
-			return false;
-		}
-
-		Boolean Add(const T val)
-		{
-			auto* iterationNode = fFirstNode;
-			MUST_PASS(iterationNode);
-
-			while (iterationNode)
-			{
-				if (!iterationNode->fUsed)
-				{
-					iterationNode->fVal	  = val;
-					iterationNode->fIndex = 0;
-
-					iterationNode->fUsed = true;
-
-					++fNodeCount;
-
-					return true;
-				}
-
-				iterationNode = iterationNode->fNext;
-			}
-
-			return false;
-		}
-
-	private:
-		/* Avoid useless lookups */
-		MutableLinkedList<T>* fLastNode{nullptr};
-		MutableLinkedList<T>* fFirstNode{nullptr};
-
-		/* Number of nodes inside of this dynamic array. */
-		Kernel::SizeT fNodeCount{0};
-
-	private:
-		// don't remove that
-		friend MutableArray<T>;
-	};
-
-	template <typename T>
-	class MutableArray : public NullableMutableArray<voidPtr, nullptr>
-	{
-	public:
-		// explicit this.
-		explicit MutableArray() = default;
-		virtual ~MutableArray() = default;
-
-		NE_COPY_DEFAULT(MutableArray)
-
-	public:
-		Boolean Add(const T val)
-		{
-			auto* iterationNode = fFirstNode;
-
-			if (!iterationNode)
-			{
-				fFirstNode	  = new MutableLinkedList<T>();
-				iterationNode = fFirstNode;
-			}
-
-			MUST_PASS(iterationNode);
-
-			while (iterationNode)
-			{
-				if (!iterationNode->fUsed)
-				{
-					iterationNode->fVal	  = val;
-					iterationNode->fIndex = 0;
-
-					iterationNode->fUsed = true;
-
-					++fNodeCount;
-
-					return true;
-				}
-
-				iterationNode = iterationNode->fNext;
-			}
-
-			return false;
-		}
+namespace Kernel {
+template <typename T>
+class MutableArray;
+
+template <typename T, T _PlaceHolderValue>
+class NullableMutableArray;
+
+template <typename T>
+class MutableLinkedList {
+ public:
+  T       fVal;
+  SizeT   fIndex{0};
+  Boolean fUsed{false};
+
+  MutableLinkedList* fPrev{nullptr};
+  MutableLinkedList* fNext{nullptr};
+};
+
+template <typename T, T _PlaceHolderValue>
+class NullableMutableArray {
+ public:
+  // explicit this.
+  explicit NullableMutableArray() : fFirstNode(new MutableLinkedList<T>()) {}
+
+  /*
+   * We free all the nodes allocated by the array
+   * and store the next one inside "NextIt"
+   */
+
+  virtual ~NullableMutableArray() {
+    auto*                 It     = fFirstNode;
+    MutableLinkedList<T>* NextIt = nullptr;
+
+    while (It) {
+      NextIt = It->fNext;
+      delete It;
+
+      It = NextIt;
+    }
+  }
+
+  NullableMutableArray& operator=(const NullableMutableArray&) = default;
+  NullableMutableArray(const NullableMutableArray&)            = default;
+
+  operator bool() { return Count() > 1; }
+
+ public:
+  T operator[](SizeT Index) const {
+    TRY_FIND_NODE(first, fFirstNode);
+    TRY_FIND_NODE(last, fLastNode);
+
+    return _PlaceHolderValue;
+  }
+
+  SizeT Count() const { return fNodeCount; }
+
+ public:
+  Boolean Remove(SizeT Index) {
+    TRY_REMOVE_NODE(fFirstNode);
+    TRY_REMOVE_NODE(fLastNode);
+
+    return false;
+  }
+
+  Boolean Add(const T val) {
+    auto* iterationNode = fFirstNode;
+    MUST_PASS(iterationNode);
+
+    while (iterationNode) {
+      if (!iterationNode->fUsed) {
+        iterationNode->fVal   = val;
+        iterationNode->fIndex = 0;
+
+        iterationNode->fUsed = true;
+
+        ++fNodeCount;
+
+        return true;
+      }
+
+      iterationNode = iterationNode->fNext;
+    }
+
+    return false;
+  }
+
+ private:
+  /* Avoid useless lookups */
+  MutableLinkedList<T>* fLastNode{nullptr};
+  MutableLinkedList<T>* fFirstNode{nullptr};
+
+  /* Number of nodes inside of this dynamic array. */
+  Kernel::SizeT fNodeCount{0};
+
+ private:
+  // don't remove that
+  friend MutableArray<T>;
+};
+
+template <typename T>
+class MutableArray : public NullableMutableArray<voidPtr, nullptr> {
+ public:
+  // explicit this.
+  explicit MutableArray() = default;
+  virtual ~MutableArray() = default;
+
+  NE_COPY_DEFAULT(MutableArray)
+
+ public:
+  Boolean Add(const T val) {
+    auto* iterationNode = fFirstNode;
+
+    if (!iterationNode) {
+      fFirstNode    = new MutableLinkedList<T>();
+      iterationNode = fFirstNode;
+    }
+
+    MUST_PASS(iterationNode);
+
+    while (iterationNode) {
+      if (!iterationNode->fUsed) {
+        iterationNode->fVal   = val;
+        iterationNode->fIndex = 0;
+
+        iterationNode->fUsed = true;
+
+        ++fNodeCount;
+
+        return true;
+      }
+
+      iterationNode = iterationNode->fNext;
+    }
+
+    return false;
+  }
+
+ public:
+  Ref<T> operator[](SizeT Index) const {
+    TRY_FIND_NODE2(first, fFirstNode);
+    TRY_FIND_NODE2(last, fLastNode);
 
-	public:
-		Ref<T> operator[](SizeT Index) const
-		{
-			TRY_FIND_NODE2(first, fFirstNode);
-			TRY_FIND_NODE2(last, fLastNode);
-
-			return {};
-		}
+    return {};
+  }
 
-		SizeT Count() const
-		{
-			return fNodeCount;
-		}
+  SizeT Count() const { return fNodeCount; }
 
-		bool Contains(T& value) noexcept
-		{
-			MutableLinkedList<T>* first = fFirstNode;
+  bool Contains(T& value) noexcept {
+    MutableLinkedList<T>* first = fFirstNode;
 
-			while (first)
-			{
-				if (first->fVal == value && first->fUsed)
-					return true;
+    while (first) {
+      if (first->fVal == value && first->fUsed) return true;
 
-				first = first->fNext;
-			}
+      first = first->fNext;
+    }
 
-			return false;
-		}
+    return false;
+  }
 
-	private:
-		/* Avoid useless lookups */
-		MutableLinkedList<T>* fLastNode{nullptr};
-		MutableLinkedList<T>* fFirstNode{nullptr};
+ private:
+  /* Avoid useless lookups */
+  MutableLinkedList<T>* fLastNode{nullptr};
+  MutableLinkedList<T>* fFirstNode{nullptr};
 
-		/* Number of nodes inside of this dynamic array. */
-		Kernel::SizeT fNodeCount{0};
-	};
-} // namespace Kernel
+  /* Number of nodes inside of this dynamic array. */
+  Kernel::SizeT fNodeCount{0};
+};
+}  // namespace Kernel
diff --git a/dev/kernel/NewKit/New.h b/dev/kernel/NewKit/New.h
index 7571206c..de242141 100644
--- a/dev/kernel/NewKit/New.h
+++ b/dev/kernel/NewKit/New.h
@@ -1,7 +1,7 @@
 
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
diff --git a/dev/kernel/NewKit/NewKit.h b/dev/kernel/NewKit/NewKit.h
index 6c5f033b..66ca2bb3 100644
--- a/dev/kernel/NewKit/NewKit.h
+++ b/dev/kernel/NewKit/NewKit.h
@@ -1,7 +1,7 @@
 
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
diff --git a/dev/kernel/NewKit/OwnPtr.h b/dev/kernel/NewKit/OwnPtr.h
index f15bc339..f00f51c4 100644
--- a/dev/kernel/NewKit/OwnPtr.h
+++ b/dev/kernel/NewKit/OwnPtr.h
@@ -1,7 +1,7 @@
 
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
@@ -11,85 +11,58 @@
 #include <NewKit/KernelPanic.h>
 #include <NewKit/Ref.h>
 
-namespace Kernel
-{
-	template <typename T>
-	class OwnPtr;
-
-	template <typename T>
-	class NonNullRefPtr;
-
-	template <typename T>
-	class OwnPtr final
-	{
-	public:
-		OwnPtr()
-		{
-		}
-		~OwnPtr()
-		{
-			this->Delete();
-		}
-
-		OwnPtr& operator=(const OwnPtr&) = default;
-		OwnPtr(const OwnPtr&)			 = default;
-
-	public:
-		template <typename... Args>
-		bool New(Args&&... arg)
-		{
-			if (fCls)
-			{
-				return false;
-			}
-
-			fCls = new T(arg...);
-			return fCls;
-		}
-
-		void Delete()
-		{
-			if (fCls)
-				delete fCls;
-
-			fCls = nullptr;
-		}
-
-		T* operator->() const
-		{
-			return fCls;
-		}
-
-		T* Raw()
-		{
-			return fCls;
-		}
-
-		Ref<T> AsRef()
-		{
-			return Ref<T>(fCls);
-		}
-
-		operator bool()
-		{
-			return fCls;
-		}
-		bool operator!()
-		{
-			return !fCls;
-		}
-
-	private:
-		T* fCls;
-	};
-
-	template <typename T, typename... Args>
-	inline OwnPtr<T> mm_make_own_ptr(Args... args)
-	{
-		OwnPtr<T> ret;
-		ret.template New<Args...>(forward(args)...);
-		MUST_PASS(ret);
-
-		return ret;
-	}
-} // namespace Kernel
+namespace Kernel {
+template <typename T>
+class OwnPtr;
+
+template <typename T>
+class NonNullRefPtr;
+
+template <typename T>
+class OwnPtr final {
+ public:
+  OwnPtr() {}
+  ~OwnPtr() { this->Delete(); }
+
+  OwnPtr& operator=(const OwnPtr&) = default;
+  OwnPtr(const OwnPtr&)            = default;
+
+ public:
+  template <typename... Args>
+  bool New(Args&&... arg) {
+    if (fCls) {
+      return false;
+    }
+
+    fCls = new T(arg...);
+    return fCls;
+  }
+
+  void Delete() {
+    if (fCls) delete fCls;
+
+    fCls = nullptr;
+  }
+
+  T* operator->() const { return fCls; }
+
+  T* Raw() { return fCls; }
+
+  Ref<T> AsRef() { return Ref<T>(fCls); }
+
+  operator bool() { return fCls; }
+  bool operator!() { return !fCls; }
+
+ private:
+  T* fCls;
+};
+
+template <typename T, typename... Args>
+inline OwnPtr<T> mm_make_own_ptr(Args... args) {
+  OwnPtr<T> ret;
+  ret.template New<Args...>(forward(args)...);
+  MUST_PASS(ret);
+
+  return ret;
+}
+}  // namespace Kernel
diff --git a/dev/kernel/NewKit/PageMgr.h b/dev/kernel/NewKit/PageMgr.h
index bc8ee776..3aef2733 100644
--- a/dev/kernel/NewKit/PageMgr.h
+++ b/dev/kernel/NewKit/PageMgr.h
@@ -3,7 +3,7 @@
 
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
@@ -12,70 +12,65 @@
 #include <NewKit/Defines.h>
 #include <NewKit/Ref.h>
 
-namespace Kernel
-{
-	class PageMgr;
-
-	class PTEWrapper final
-	{
-	public:
-		explicit PTEWrapper(Boolean Rw = false, Boolean User = false, Boolean ExecDisable = false, UIntPtr Address = 0);
-
-		~PTEWrapper();
-
-		PTEWrapper& operator=(const PTEWrapper&) = default;
-		PTEWrapper(const PTEWrapper&)			 = default;
-
-	public:
-		UIntPtr VirtualAddress();
-
-		Void NoExecute(const bool enable = false);
-		Bool NoExecute();
-
-		operator bool()
-		{
-			return fVirtAddr;
-		}
-
-		bool Reclaim();
-		bool Shareable();
-		bool Present();
-		bool Access();
-
-	private:
-		Boolean fRw;
-		Boolean fUser;
-		Boolean fExecDisable;
-		UIntPtr fVirtAddr;
-		Boolean fCache;
-		Boolean fShareable;
-		Boolean fWt;
-		Boolean fPresent;
-		Boolean fAccessed;
-
-	private:
-		friend class PageMgr;
-		friend class Pmm;
-	};
-
-	struct PageMgr final
-	{
-	public:
-		PageMgr()  = default;
-		~PageMgr() = default;
-
-		PageMgr& operator=(const PageMgr&) = default;
-		PageMgr(const PageMgr&)			   = default;
-
-	public:
-		PTEWrapper Request(Boolean Rw, Boolean User, Boolean ExecDisable, SizeT Sz, SizeT Pad);
-		bool	   Free(Ref<PTEWrapper>& wrapper);
-
-	private:
-		void FlushTLB();
-
-	private:
-		friend PTEWrapper;
-		friend class Pmm;
-	};
-} // namespace Kernel
+namespace Kernel {
+class PageMgr;
+
+class PTEWrapper final {
+ public:
+  explicit PTEWrapper(Boolean Rw = false, Boolean User = false, Boolean ExecDisable = false,
+                      UIntPtr Address = 0);
+
+  ~PTEWrapper();
+
+  PTEWrapper& operator=(const PTEWrapper&) = default;
+  PTEWrapper(const PTEWrapper&)            = default;
+
+ public:
+  UIntPtr VirtualAddress();
+
+  Void NoExecute(const bool enable = false);
+  Bool NoExecute();
+
+  operator bool() { return fVirtAddr; }
+
+  bool Reclaim();
+  bool Shareable();
+  bool Present();
+  bool Access();
+
+ private:
+  Boolean fRw;
+  Boolean fUser;
+  Boolean fExecDisable;
+  UIntPtr fVirtAddr;
+  Boolean fCache;
+  Boolean fShareable;
+  Boolean fWt;
+  Boolean fPresent;
+  Boolean fAccessed;
+
+ private:
+  friend class PageMgr;
+  friend class Pmm;
+};
+
+struct PageMgr final {
+ public:
+  PageMgr()  = default;
+  ~PageMgr() = default;
+
+  PageMgr& operator=(const PageMgr&) = default;
+  PageMgr(const PageMgr&)            = default;
+
+ public:
+  PTEWrapper Request(Boolean Rw, Boolean User, Boolean ExecDisable, SizeT Sz, SizeT Pad);
+  bool       Free(Ref<PTEWrapper>& wrapper);
+
+ private:
+  void FlushTLB();
+
+ private:
+  friend PTEWrapper;
+  friend class Pmm;
+};
+}  // namespace Kernel
diff --git a/dev/kernel/NewKit/Pair.h b/dev/kernel/NewKit/Pair.h
index 8124cf56..28512831 100644
--- a/dev/kernel/NewKit/Pair.h
+++ b/dev/kernel/NewKit/Pair.h
@@ -1,6 +1,6 @@
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
@@ -8,7 +8,6 @@
 
 #include <NewKit/Defines.h>
 
-namespace Kernel
-{
-	class Pair;
-} // namespace Kernel
+namespace Kernel {
+class Pair;
+}  // namespace Kernel
diff --git a/dev/kernel/NewKit/Pmm.h b/dev/kernel/NewKit/Pmm.h
index 45770f86..41d988e1 100644
--- a/dev/kernel/NewKit/Pmm.h
+++ b/dev/kernel/NewKit/Pmm.h
@@ -1,7 +1,7 @@
 
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
@@ -10,35 +10,30 @@
 #include <NewKit/PageMgr.h>
 #include <NewKit/Ref.h>
 
-namespace Kernel
-{
-	class Pmm;
-	class PTEWrapper;
-
-	class Pmm final
-	{
-	public:
-		explicit Pmm();
-		~Pmm();
-
-		Pmm& operator=(const Pmm&) = delete;
-		Pmm(const Pmm&)			   = default;
-
-		Ref<PTEWrapper> RequestPage(Boolean user = false, Boolean readWrite = false);
-		Boolean			FreePage(Ref<PTEWrapper> refPage);
-
-		Boolean ToggleRw(Ref<PTEWrapper> refPage, Boolean enable = true);
-		Boolean TogglePresent(Ref<PTEWrapper> refPage, Boolean enable = true);
-		Boolean ToggleUser(Ref<PTEWrapper> refPage, Boolean enable = true);
-		Boolean ToggleShare(Ref<PTEWrapper> refPage, Boolean enable = true);
-
-		/// @brief Get the page manager of this.
-		Ref<PageMgr>& Leak()
-		{
-			return fPageMgr;
-		}
-
-	private:
-		Ref<PageMgr> fPageMgr;
-	};
-} // namespace Kernel
+namespace Kernel {
+class Pmm;
+class PTEWrapper;
+
+class Pmm final {
+ public:
+  explicit Pmm();
+  ~Pmm();
+
+  Pmm& operator=(const Pmm&) = delete;
+  Pmm(const Pmm&)            = default;
+
+  Ref<PTEWrapper> RequestPage(Boolean user = false, Boolean readWrite = false);
+  Boolean         FreePage(Ref<PTEWrapper> refPage);
+
+  Boolean ToggleRw(Ref<PTEWrapper> refPage, Boolean enable = true);
+  Boolean TogglePresent(Ref<PTEWrapper> refPage, Boolean enable = true);
+  Boolean ToggleUser(Ref<PTEWrapper> refPage, Boolean enable = true);
+  Boolean ToggleShare(Ref<PTEWrapper> refPage, Boolean enable = true);
+
+  /// @brief Get the page manager of this.
+  Ref<PageMgr>& Leak() { return fPageMgr; }
+
+ private:
+  Ref<PageMgr> fPageMgr;
+};
+}  // namespace Kernel
diff --git a/dev/kernel/NewKit/Ref.h b/dev/kernel/NewKit/Ref.h
index 7ec0825a..6737ce09 100644
--- a/dev/kernel/NewKit/Ref.h
+++ b/dev/kernel/NewKit/Ref.h
@@ -1,109 +1,79 @@
 
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
 #ifndef _NEWKIT_REF_H_
 #define _NEWKIT_REF_H_
 
+#include <KernelKit/MemoryMgr.h>
 #include <NewKit/Defines.h>
 #include <NewKit/KernelPanic.h>
-#include <KernelKit/MemoryMgr.h>
 
-namespace Kernel
-{
-	template <typename T>
-	class Ref final
-	{
-	public:
-		Ref() = default;
-
-		~Ref()
-		{
-			if (mm_is_valid_heap(fClass))
-				delete fClass;
-		}
-
-	public:
-		Ref(T* cls)
-			: fClass(cls)
-		{
-		}
-
-		Ref(T cls)
-			: fClass(nullptr)
-		{
-			fClass = new T(cls);
-		}
-
-		Ref& operator=(T ref)
-		{
-			if (!fClass)
-				return *this;
-
-			fClass = &ref;
-			return *this;
-		}
-
-	public:
-		T operator->() const
-		{
-			MUST_PASS(*fClass);
-			return *fClass;
-		}
-
-		T& Leak() noexcept
-		{
-			return *fClass;
-		}
-
-		T& TryLeak() const noexcept
-		{
-			MUST_PASS(*fClass);
-			return *fClass;
-		}
-
-		T operator*()
-		{
-			return *fClass;
-		}
-
-		operator bool() noexcept
-		{
-			return fClass;
-		}
-
-	private:
-		T* fClass{nullptr};
-	};
-
-	template <typename T>
-	class NonNullRef final
-	{
-	public:
-		NonNullRef()		= delete;
-		NonNullRef(nullPtr) = delete;
-
-		NonNullRef(T* ref)
-			: fRef(ref)
-		{
-			MUST_PASS(ref);
-		}
-
-		Ref<T>& operator->()
-		{
-			MUST_PASS(fRef);
-			return fRef;
-		}
-
-		NonNullRef& operator=(const NonNullRef<T>& ref) = delete;
-		NonNullRef(const NonNullRef<T>& ref)			= default;
-
-	private:
-		Ref<T> fRef{nullptr};
-	};
-} // namespace Kernel
-
-#endif // ifndef _NEWKIT_REF_H_
+namespace Kernel {
+template <typename T>
+class Ref final {
+ public:
+  Ref() = default;
+
+  ~Ref() {
+    if (mm_is_valid_heap(fClass)) delete fClass;
+  }
+
+ public:
+  Ref(T* cls) : fClass(cls) {}
+
+  Ref(T cls) : fClass(nullptr) { fClass = new T(cls); }
+
+  Ref& operator=(T ref) {
+    if (!fClass) return *this;
+
+    fClass = &ref;
+    return *this;
+  }
+
+ public:
+  T operator->() const {
+    MUST_PASS(*fClass);
+    return *fClass;
+  }
+
+  T& Leak() noexcept { return *fClass; }
+
+  T& TryLeak() const noexcept {
+    MUST_PASS(*fClass);
+    return *fClass;
+  }
+
+  T operator*() { return *fClass; }
+
+  operator bool() noexcept { return fClass; }
+
+ private:
+  T* fClass{nullptr};
+};
+
+template <typename T>
+class NonNullRef final {
+ public:
+  NonNullRef()        = delete;
+  NonNullRef(nullPtr) = delete;
+
+  NonNullRef(T* ref) : fRef(ref) { MUST_PASS(ref); }
+
+  Ref<T>& operator->() {
+    MUST_PASS(fRef);
+    return fRef;
+  }
+
+  NonNullRef& operator=(const NonNullRef<T>& ref) = delete;
+  NonNullRef(const NonNullRef<T>& ref)            = default;
+
+ private:
+  Ref<T> fRef{nullptr};
+};
+}  // namespace Kernel
+
+#endif  // ifndef _NEWKIT_REF_H_
diff --git a/dev/kernel/NewKit/Stream.h b/dev/kernel/NewKit/Stream.h
index dfe1881c..8b72046c 100644
--- a/dev/kernel/NewKit/Stream.h
+++ b/dev/kernel/NewKit/Stream.h
@@ -1,7 +1,7 @@
 
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
@@ -10,49 +10,36 @@
 #include <NewKit/Defines.h>
 #include <NewKit/Ref.h>
 
-namespace Kernel
-{
-	template <typename StreamTrait, typename Kind>
-	class Stream final
-	{
-	public:
-		explicit Stream(Ref<Stream> ref)
-			: fStream(ref)
-		{
-		}
-
-		~Stream() = default;
-
-		Stream& operator=(const Stream&) = default;
-		Stream(const Stream&)			 = default;
-
-		template <typename Data>
-		friend Stream<StreamTrait, Kind>& operator>>(Stream<StreamTrait, Kind>& Ks, Ref<Data>& Buf)
-		{
-			Ks.fKind = Ks.fStream->In(Buf);
-			return *Ks;
-		}
-
-		template <typename Data>
-		friend Stream<StreamTrait, Kind>& operator<<(Stream<StreamTrait, Kind>& Ks, Ref<Data>& Buf)
-		{
-			Ks.fKind = Buf;
-			Ks.fStream->Out(Buf.Leak());
-			return *Ks;
-		}
-
-		Ref<StreamTrait>& AsStreamTrait()
-		{
-			return fStream;
-		}
-
-		Ref<Kind>& AsType()
-		{
-			return fKind;
-		}
-
-	private:
-		Ref<StreamTrait> fStream;
-		Ref<Kind>		 fKind;
-	};
-} // namespace Kernel
+namespace Kernel {
+template <typename StreamTrait, typename Kind>
+class Stream final {
+ public:
+  explicit Stream(Ref<Stream> ref) : fStream(ref) {}
+
+  ~Stream() = default;
+
+  Stream& operator=(const Stream&) = default;
+  Stream(const Stream&)            = default;
+
+  template <typename Data>
+  friend Stream<StreamTrait, Kind>& operator>>(Stream<StreamTrait, Kind>& Ks, Ref<Data>& Buf) {
+    Ks.fKind = Ks.fStream->In(Buf);
+    return *Ks;
+  }
+
+  template <typename Data>
+  friend Stream<StreamTrait, Kind>& operator<<(Stream<StreamTrait, Kind>& Ks, Ref<Data>& Buf) {
+    Ks.fKind = Buf;
+    Ks.fStream->Out(Buf.Leak());
+    return *Ks;
+  }
+
+  Ref<StreamTrait>& AsStreamTrait() { return fStream; }
+
+  Ref<Kind>& AsType() { return fKind; }
+
+ private:
+  Ref<StreamTrait> fStream;
+  Ref<Kind>        fKind;
+};
+}  // namespace Kernel
diff --git a/dev/kernel/NewKit/Utils.h b/dev/kernel/NewKit/Utils.h
index 7340631b..ca1c7d1c 100644
--- a/dev/kernel/NewKit/Utils.h
+++ b/dev/kernel/NewKit/Utils.h
@@ -1,7 +1,7 @@
 
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
@@ -9,23 +9,22 @@
 
 #include <NewKit/Defines.h>
 
-namespace Kernel
-{
-	Int			rt_copy_memory(const voidPtr src, voidPtr dst, Size len);
-	Int			rt_move_memory(const voidPtr src, voidPtr dst, Size len);
-	voidPtr		rt_set_memory(voidPtr dst, UInt32 val, Size len);
-	void		rt_zero_memory(voidPtr pointer, Size len);
-	Int			rt_string_cmp(const Char* src, const Char* cmp, Size len);
-	const Char* rt_alloc_string(const Char* text);
-	Size		rt_string_len(const Char* str);
-	Size		wrt_string_len(const Utf16Char* str);
-	Size		rt_string_len(const Char* str, SizeT _len);
-	Boolean		rt_to_string(Char* str_out, UInt64 base, Int32 limit);
-	Boolean		rt_is_newln(Char chr);
-	Boolean		rt_is_space(Char chr);
-	Int32		rt_is_alnum(Int32 character);
-	Int			rt_to_uppercase(Int c);
-	Int			rt_to_lower(Int c);
-	voidPtr		rt_string_in_string(const Char* in, const Char* needle);
-	char*		rt_string_has_char(Char* str, Char chr);
-} // namespace Kernel
+namespace Kernel {
+Int         rt_copy_memory(const voidPtr src, voidPtr dst, Size len);
+Int         rt_move_memory(const voidPtr src, voidPtr dst, Size len);
+voidPtr     rt_set_memory(voidPtr dst, UInt32 val, Size len);
+void        rt_zero_memory(voidPtr pointer, Size len);
+Int         rt_string_cmp(const Char* src, const Char* cmp, Size len);
+const Char* rt_alloc_string(const Char* text);
+Size        rt_string_len(const Char* str);
+Size        wrt_string_len(const Utf16Char* str);
+Size        rt_string_len(const Char* str, SizeT _len);
+Boolean     rt_to_string(Char* str_out, UInt64 base, Int32 limit);
+Boolean     rt_is_newln(Char chr);
+Boolean     rt_is_space(Char chr);
+Int32       rt_is_alnum(Int32 character);
+Int         rt_to_uppercase(Int c);
+Int         rt_to_lower(Int c);
+voidPtr     rt_string_in_string(const Char* in, const Char* needle);
+char*       rt_string_has_char(Char* str, Char chr);
+}  // namespace Kernel
diff --git a/dev/kernel/NewKit/Variant.h b/dev/kernel/NewKit/Variant.h
index a55b8a7b..83602602 100644
--- a/dev/kernel/NewKit/Variant.h
+++ b/dev/kernel/NewKit/Variant.h
@@ -1,80 +1,61 @@
 /* -------------------------------------------
 
-	Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
 ------------------------------------------- */
 
 #pragma once
 
 #include <NewKit/Defines.h>
-#include <NewKit/KString.h>
 #include <NewKit/Json.h>
+#include <NewKit/KString.h>
 #include <SwapKit/DiskSwap.h>
 
-namespace Kernel
-{
-	class Variant final
-	{
-	public:
-		enum class VariantKind
-		{
-			kString,
-			kBlob,
-			kNull,
-			kJson,
-			kXML,
-			kSwap,
-			kInvalid,
-		};
-
-	public:
-		explicit Variant() = delete;
-
-	public:
-		NE_COPY_DEFAULT(Variant)
-
-		~Variant() = default;
-
-	public:
-		explicit Variant(KString* stringView)
-			: fPtr((VoidPtr)stringView), fKind(VariantKind::kString)
-		{
-		}
-
-		explicit Variant(Json* json)
-			: fPtr((VoidPtr)json), fKind(VariantKind::kJson)
-		{
-		}
-
-		explicit Variant(nullPtr ptr)
-			: fPtr(ptr), fKind(VariantKind::kNull)
-		{
-		}
-
-		explicit Variant(SWAP_DISK_HEADER* ptr)
-			: fPtr(ptr), fKind(VariantKind::kSwap)
-		{
-		}
-
-		explicit Variant(VoidPtr ptr)
-			: fPtr(ptr), fKind(VariantKind::kBlob)
-		{
-		}
-
-	public:
-		const Char* ToString();
-		VoidPtr		Leak();
-
-		template <typename T>
-		T* As()
-		{
-			return reinterpret_cast<T*>(fPtr);
-		}
-
-		VariantKind& Kind();
-
-	private:
-		voidPtr		fPtr{nullptr};
-		VariantKind fKind{VariantKind::kNull};
-	};
-} // namespace Kernel
+namespace Kernel {
+class Variant final {
+ public:
+  enum class VariantKind {
+    kString,
+    kBlob,
+    kNull,
+    kJson,
+    kXML,
+    kSwap,
+    kInvalid,
+  };
+
+ public:
+  explicit Variant() = delete;
+
+ public:
+  NE_COPY_DEFAULT(Variant)
+
+  ~Variant() = default;
+
+ public:
+  explicit Variant(KString* stringView) : fPtr((VoidPtr) stringView), fKind(VariantKind::kString) {}
+
+  explicit Variant(Json* json) : fPtr((VoidPtr) json), fKind(VariantKind::kJson) {}
+
+  explicit Variant(nullPtr ptr) : fPtr(ptr), fKind(VariantKind::kNull) {}
+
+  explicit Variant(SWAP_DISK_HEADER* ptr) : fPtr(ptr), fKind(VariantKind::kSwap) {}
+
+  explicit Variant(VoidPtr ptr) : fPtr(ptr), fKind(VariantKind::kBlob) {}
+
+ public:
+  const Char* ToString();
+  VoidPtr     Leak();
+
+  template <typename T>
+  T* As() {
+    return reinterpret_cast<T*>(fPtr);
+  }
+
+  VariantKind& Kind();
+
+ private:
+  voidPtr     fPtr{nullptr};
+  VariantKind fKind{VariantKind::kNull};
+};
+}  // namespace Kernel