diff --git a/Core/Lock.cpp b/Core/Lock.cpp
index 5155f6a..8753ac2 100644
--- a/Core/Lock.cpp
+++ b/Core/Lock.cpp
@@ -49,7 +49,7 @@ int LockClass::Lock(const char *FunctionName)
     LockData.AttemptingToGet = FunctionName;
 Retry:
     unsigned int i = 0;
-    while (IsLocked.Exchange(true, MemoryBorder::Acquire) && ++i < 0x10000000)
+    while (IsLocked.Exchange(true, MemoryOrder::Acquire) && ++i < 0x10000000)
         CPU::Pause();
     if (i >= 0x10000000)
     {
@@ -77,7 +77,7 @@ int LockClass::Unlock()
     // IsLocked = false;
 
     __sync_synchronize();
-    IsLocked.Store(false, MemoryBorder::Release);
+    IsLocked.Store(false, MemoryOrder::Release);
     LockData.Count--;
     IsLocked = false;
 
@@ -114,7 +114,7 @@ int LockClass::TimeoutLock(const char *FunctionName, uint64_t Timeout)
     Atomic<uint64_t> Target = 0;
 Retry:
     unsigned int i = 0;
-    while (IsLocked.Exchange(true, MemoryBorder::Acquire) && ++i < 0x10000000)
+    while (IsLocked.Exchange(true, MemoryOrder::Acquire) && ++i < 0x10000000)
         CPU::Pause();
     if (i >= 0x10000000)
     {
diff --git a/include/atomic.hpp b/include/atomic.hpp
index 69bf6b8..1cca003 100644
--- a/include/atomic.hpp
+++ b/include/atomic.hpp
@@ -5,10 +5,10 @@
 #define builtin_atomic_n(name) __atomic_##name##_n
 #define builtin_atomic(name) __atomic_##name
 
-enum MemoryBorder
+enum MemoryOrder
 {
     /**
-     * @brief Relaxed memory border
+     * @brief Relaxed memory order
      *
      * This memory ordering specifies that the
      * operation on the atomic variable has no
@@ -19,7 +19,7 @@ enum MemoryBorder
     Relaxed = __ATOMIC_RELAXED,
 
     /**
-     * @brief Acquire memory border
+     * @brief Acquire memory order
      *
      * This memory ordering specifies that subsequent
      * memory accesses after the atomic operation
@@ -30,7 +30,7 @@ enum MemoryBorder
     Acquire = __ATOMIC_ACQUIRE,
 
     /**
-     * @brief Release memory border
+     * @brief Release memory order
      *
      * This memory ordering specifies that previous
      * memory accesses before the atomic operation
@@ -41,7 +41,7 @@ enum MemoryBorder
     Release = __ATOMIC_RELEASE,
 
     /**
-     * @brief Acquire and release memory border
+     * @brief Acquire and release memory order
      *
      * This memory ordering combines both the acquire
      * and release memory orderings. This ordering
@@ -51,7 +51,7 @@ enum MemoryBorder
     AcqRel = __ATOMIC_ACQ_REL,
 
     /**
-     * @brief Sequentially consistent memory border
+     * @brief Sequentially consistent memory order
      *
      * This memory ordering is a combination of
      * @see AcqRel and the additional
@@ -72,10 +72,10 @@ public:
     /**
      * @brief Load the value of the atomic variable
      *
-     * @param Order The memory border to use
+     * @param Order The memory order to use
      * @return T The value of the atomic variable
      */
-    T Load(MemoryBorder Order = MemoryBorder::SeqCst)
+    T Load(MemoryOrder Order = MemoryOrder::SeqCst)
     {
         return builtin_atomic_n(load)(&m_Value, Order);
     }
@@ -84,9 +84,9 @@ public:
      * @brief Store a value to the atomic variable
      *
      * @param v The value to store
-     * @param Order The memory border to use
+     * @param Order The memory order to use
      */
-    void Store(T v, MemoryBorder Order = MemoryBorder::SeqCst)
+    void Store(T v, MemoryOrder Order = MemoryOrder::SeqCst)
     {
         return builtin_atomic_n(store)(&m_Value, v, Order);
     }
@@ -95,10 +95,10 @@ public:
      * @brief Exchange the value of the atomic variable
      *
      * @param v The value to exchange
-     * @param Order The memory border to use
+     * @param Order The memory order to use
      * @return T The old value of the atomic variable
      */
-    T Exchange(T v, MemoryBorder Order = MemoryBorder::SeqCst)
+    T Exchange(T v, MemoryOrder Order = MemoryOrder::SeqCst)
     {
         return builtin_atomic_n(exchange)(&m_Value, v, Order);
     }
@@ -108,11 +108,11 @@ public:
      *
      * @param Expected The expected value
      * @param Desired The desired value
-     * @param Order The memory border to use
+     * @param Order The memory order to use
      * @return true If the exchange was successful
      * @return false If the exchange was not successful
      */
-    bool CompareExchange(T &Expected, T Desired, MemoryBorder Order = MemoryBorder::SeqCst)
+    bool CompareExchange(T &Expected, T Desired, MemoryOrder Order = MemoryOrder::SeqCst)
     {
         return builtin_atomic_n(compare_exchange)(&m_Value, &Expected, Desired, true, Order, Order);
     }
@@ -121,10 +121,10 @@ public:
      * @brief Fetch and add the value of the atomic variable
      *
      * @param v The value to add
-     * @param Order The memory border to use
+     * @param Order The memory order to use
      * @return T The old value of the atomic variable
      */
-    T FetchAdd(T v, MemoryBorder Order = MemoryBorder::SeqCst)
+    T FetchAdd(T v, MemoryOrder Order = MemoryOrder::SeqCst)
     {
         return builtin_atomic(fetch_add)(&m_Value, v, Order);
     }
@@ -133,10 +133,10 @@ public:
      * @brief Fetch and subtract the value of the atomic variable
      *
      * @param v The value to subtract
-     * @param Order The memory border to use
+     * @param Order The memory order to use
      * @return T The old value of the atomic variable
      */
-    T FetchSub(T v, MemoryBorder Order = MemoryBorder::SeqCst)
+    T FetchSub(T v, MemoryOrder Order = MemoryOrder::SeqCst)
     {
         return builtin_atomic(fetch_sub)(&m_Value, v, Order);
     }
@@ -145,10 +145,10 @@ public:
      * @brief Fetch and and the value of the atomic variable
      *
      * @param v The value to and
-     * @param Order The memory border to use
+     * @param Order The memory order to use
      * @return T The old value of the atomic variable
      */
-    T FetchAnd(T v, MemoryBorder Order = MemoryBorder::SeqCst)
+    T FetchAnd(T v, MemoryOrder Order = MemoryOrder::SeqCst)
     {
         return builtin_atomic(fetch_and)(&m_Value, v, Order);
     }
@@ -157,10 +157,10 @@ public:
      * @brief Fetch and or the value of the atomic variable
      *
      * @param v The value to or
-     * @param Order The memory border to use
+     * @param Order The memory order to use
      * @return T The old value of the atomic variable
      */
-    T FetchOr(T v, MemoryBorder Order = MemoryBorder::SeqCst)
+    T FetchOr(T v, MemoryOrder Order = MemoryOrder::SeqCst)
     {
         return builtin_atomic(fetch_or)(&m_Value, v, Order);
     }
@@ -169,10 +169,10 @@ public:
      * @brief Fetch and xor the value of the atomic variable
      *
      * @param v The value to xor
-     * @param Order The memory border to use
+     * @param Order The memory order to use
      * @return T The old value of the atomic variable
      */
-    T FetchXor(T v, MemoryBorder Order = MemoryBorder::SeqCst)
+    T FetchXor(T v, MemoryOrder Order = MemoryOrder::SeqCst)
     {
         return builtin_atomic(fetch_xor)(&m_Value, v, Order);
     }
@@ -181,10 +181,10 @@ public:
      * @brief Fetch and nand the value of the atomic variable
      *
      * @param v The value to nand
-     * @param Order The memory border to use
+     * @param Order The memory order to use
      * @return T The old value of the atomic variable
      */
-    T FetchNand(T v, MemoryBorder Order = MemoryBorder::SeqCst)
+    T FetchNand(T v, MemoryOrder Order = MemoryOrder::SeqCst)
     {
         return builtin_atomic(fetch_nand)(&m_Value, v, Order);
     }