10 files changed, 22 insertions, 25 deletions
diff --git a/src/kernel/NeKit/Crc32.h b/src/kernel/NeKit/Crc32.h
index 3c6a904f..125ee5b7 100644
--- a/src/kernel/NeKit/Crc32.h
+++ b/src/kernel/NeKit/Crc32.h
@@ -14,7 +14,7 @@
 #include <NeKit/Defines.h>
 
 namespace Kernel {
-UInt32 ke_calculate_crc32(const VoidPtr crc, Int32 len) noexcept;
+UInt32 ke_calculate_crc32(const VoidPtr crc, Int32 len);
 }  // namespace Kernel
 
 #endif  // !NEKIT_CRC32_H
diff --git a/src/kernel/NeKit/Defines.h b/src/kernel/NeKit/Defines.h
index 1a6a2cf6..e53616a9 100644
--- a/src/kernel/NeKit/Defines.h
+++ b/src/kernel/NeKit/Defines.h
@@ -127,7 +127,7 @@ class ICodec {
   /// @param type (a1) the data.
   /// @return a1 as Char*
   template <typename T>
-  const Char* AsBytes(T type) noexcept {
+  const Char* AsBytes(T type) {
     NE_UNUSED(type);
     return nullptr;
   }
@@ -137,7 +137,7 @@ class ICodec {
   /// @param type (a1) the data.
   /// @return a1 as Char*
   template <typename OutputClass, typename FactoryClass>
-  OutputClass* Construct(Char* type) noexcept {
+  OutputClass* Construct(Char* type) {
     FactoryClass class_fac;
     return class_fac.template From<OutputClass>(type);
   }
@@ -148,7 +148,7 @@ class ICodec {
   /// @param type the class to cast.
   /// @return the class as Y.
   template <typename T, typename Y>
-  Y As(T type) noexcept {
+  Y As(T type) {
     if (type.template IsSerializable()) {
       return reinterpret_cast<Char*>(type);
     }
diff --git a/src/kernel/NeKit/Function.h b/src/kernel/NeKit/Function.h
index 70242bc3..5dea8f85 100644
--- a/src/kernel/NeKit/Function.h
+++ b/src/kernel/NeKit/Function.h
@@ -41,11 +41,9 @@ class Function final {
   bool operator!() { return !fFn; }
 
  private:
-  T(*fFn)
-  (Args... args){nullptr};
+  T (*fFn)(Args... args){nullptr};
 };
 
 template <typename T, typename... Args>
 using FunctionOr = ErrorOr<Function<T, Args...>>;
 }  // namespace Kernel
-
diff --git a/src/kernel/NeKit/Json.h b/src/kernel/NeKit/Json.h
index 1e804354..82ce3b99 100644
--- a/src/kernel/NeKit/Json.h
+++ b/src/kernel/NeKit/Json.h
@@ -34,16 +34,15 @@ class JsonObject final {
     key += kNeJsonNullValue;
 
     this->AsKey()   = key;
-    this->AsValue()   = key;
+    this->AsValue() = key;
   }
 
   explicit JsonObject(SizeT lhsLen, SizeT rhsLen) : fKey(lhsLen), fValue(rhsLen) {
-
     KBasicString<CharKind> key = KString(lhsLen);
-    this->AsKey()   = key;
+    this->AsKey()              = key;
 
     KBasicString<CharKind> value = KString(rhsLen);
-    this->AsValue()   = value;
+    this->AsValue()              = value;
   }
 
   ~JsonObject() = default;
@@ -54,7 +53,7 @@ class JsonObject final {
   Bool& IsUndefined() { return fUndefined; }
 
  private:
-  Bool           fUndefined;  // is this instance undefined?
+  Bool                   fUndefined;  // is this instance undefined?
   KBasicString<CharKind> fKey;
   KBasicString<CharKind> fValue;
 
diff --git a/src/kernel/NeKit/Macros.h b/src/kernel/NeKit/Macros.h
index 5949b414..80a2ff6c 100644
--- a/src/kernel/NeKit/Macros.h
+++ b/src/kernel/NeKit/Macros.h
@@ -16,7 +16,7 @@
 #endif
 
 #ifndef kib_cast
-#define kib_cast(X) (Kernel::UInt64)((X) *1024)
+#define kib_cast(X) (Kernel::UInt64)((X) * 1024)
 #endif
 
 #ifndef MIB
@@ -117,7 +117,7 @@
 #define NE_UNUSED(X) ((Kernel::Void) X)
 
 #ifndef RGB
-#define RGB(R, G, B) ((Kernel::UInt32)((0xFF << 24) | ((R) << 16) | ((G) << 8) | (B)))
+#define RGB(R, G, B) ((Kernel::UInt32) ((0xFF << 24) | ((R) << 16) | ((G) << 8) | (B)))
 #endif  // !RGB
 
 #ifdef __NE_AMD64__
diff --git a/src/kernel/NeKit/MutableArray.h b/src/kernel/NeKit/MutableArray.h
index e1138b3b..e14afbfe 100644
--- a/src/kernel/NeKit/MutableArray.h
+++ b/src/kernel/NeKit/MutableArray.h
@@ -180,7 +180,7 @@ class MutableArray : public NullableMutableArray<voidPtr, nullptr> {
 
   SizeT Count() const { return fNodeCount; }
 
-  bool Contains(T& value) noexcept {
+  bool Contains(T& value) {
     MutableLinkedList<T>* first = fFirstNode;
 
     while (first) {
diff --git a/src/kernel/NeKit/New.h b/src/kernel/NeKit/New.h
index 36830129..bd986347 100644
--- a/src/kernel/NeKit/New.h
+++ b/src/kernel/NeKit/New.h
@@ -15,6 +15,6 @@ typedef __SIZE_TYPE__ size_t;
 void* operator new(size_t);
 void* operator new[](size_t);
 
-void operator delete(void*) noexcept;
+void operator delete(void*);
 void operator delete(void*, unsigned long);
-void operator delete[](void*) noexcept;
+void operator delete[](void*);
diff --git a/src/kernel/NeKit/OwnPtr.h b/src/kernel/NeKit/OwnPtr.h
index c8ceb1a2..bec2813b 100644
--- a/src/kernel/NeKit/OwnPtr.h
+++ b/src/kernel/NeKit/OwnPtr.h
@@ -50,7 +50,7 @@ class OwnPtr final {
 
   Ref<T> AsRef() { return Ref<T>(fCls); }
 
-       operator bool() { return fCls; }
+  operator bool() { return fCls; }
   bool operator!() { return !fCls; }
 
  private:
diff --git a/src/kernel/NeKit/Ref.h b/src/kernel/NeKit/Ref.h
index dac701e0..59991442 100644
--- a/src/kernel/NeKit/Ref.h
+++ b/src/kernel/NeKit/Ref.h
@@ -37,13 +37,13 @@ class Ref final {
  public:
   T operator->() const { return fClass; }
 
-  T& Leak() noexcept { return fClass; }
+  T& Leak() { return fClass; }
 
-  T& TryLeak() noexcept { return fClass; }
+  T& TryLeak() { return fClass; }
 
   T operator*() { return fClass; }
 
-  operator bool() noexcept { return true; }
+  operator bool() { return true; }
 
  private:
   T fClass;
diff --git a/src/kernel/NeKit/Variant.h b/src/kernel/NeKit/Variant.h
index 7bcd0dff..1b0fbe5d 100644
--- a/src/kernel/NeKit/Variant.h
+++ b/src/kernel/NeKit/Variant.h
@@ -8,8 +8,8 @@
 
 #include <NeKit/Defines.h>
 #include <NeKit/Json.h>
-#include <NeKit/TOML.h>
 #include <NeKit/KString.h>
+#include <NeKit/TOML.h>
 #include <SwapKit/DiskSwap.h>
 
 namespace Kernel {
@@ -17,7 +17,7 @@ class Variant final {
  public:
   enum class VariantKind {
     kInvalid = 0,
-    kString = 200,
+    kString  = 200,
     kBlob,
     kNull,
     kJson,
@@ -55,10 +55,10 @@ class Variant final {
   /// @brief Returns the underlying pointer.
   /// @return the underlying pointer.
   /// ========================================================================
-  VoidPtr     Leak();
+  VoidPtr Leak();
 
   template <typename T>
-  T* As() noexcept {
+  T* As() {
     return reinterpret_cast<T*>(fPtr);
   }