diff --git a/Include/Hallocy/Core/Memory.h b/Include/Hallocy/Core/Memory.h
index b41c05c..b001d22 100644
--- a/Include/Hallocy/Core/Memory.h
+++ b/Include/Hallocy/Core/Memory.h
@@ -30,5 +30,6 @@
 
 HallocyError hallocy_set_memory(void *destination, int value, const size_t size);
 HallocyError hallocy_copy_memory(void *destination, void *source, const size_t size);
+HallocyError hallocy_move_memory(void *destination, void *source, const size_t size);
 
 #endif
\ No newline at end of file
diff --git a/Src/Core/Memory.c b/Src/Core/Memory.c
index 0710701..fd2e7e6 100644
--- a/Src/Core/Memory.c
+++ b/Src/Core/Memory.c
@@ -281,5 +281,165 @@ HallocyError hallocy_copy_memory(void *destination, void *source, const size_t s
         source_bytes += 1;
     }
 
+    return HALLOCY_ERROR_NONE;
+}
+
+HallocyError hallocy_move_memory(void *destination, void *source, const size_t size) {
+    if (!((void*)((size_t)source + size) > destination && source < destination)) {
+        return hallocy_copy_memory(destination, source, size);
+    }
+
+    if (destination == NULL || source == NULL) {
+        return HALLOCY_ERROR_INVALID_POINTER;
+    }
+
+    unsigned char *end_address = (unsigned char*)destination;
+
+    unsigned char *destination_bytes = (unsigned char*)destination + size;
+    unsigned char *source_bytes = (unsigned char*)source + size;
+
+    switch (hallocy_is_simd_supported()) {
+        #if defined(_M_ARM64) || defined(__aarch64__) || defined(__arm__)
+        case HALLOCY_SIMD_NEON: {
+            if ((size_t)destination_bytes % 16 == (size_t)source_bytes % 16) {
+                while (((size_t)destination_bytes % 16) != 0 && destination_bytes != end_address) {
+                    destination_bytes -= 1;
+                    source_bytes -= 1;
+                    *destination_bytes = *source_bytes;
+                }
+            }
+
+            uint8x16_t simd_value;
+            while (end_address - destination_bytes >= 16) {
+                destination_bytes -= 16;
+                source_bytes -= 16;
+
+                simd_value = vdupq_n_u8(source_bytes);
+                vst1q_u8(destination_bytes, simd_value);
+            }
+            break;
+        }
+        #else
+        case HALLOCY_SIMD_AVX512: {
+            if ((size_t)destination_bytes % 64 == (size_t)source_bytes % 64) {
+                while (((size_t)destination_bytes % 64) != 0 && destination_bytes != end_address) {
+                    destination_bytes -= 1;
+                    source_bytes -= 1;
+                    *destination_bytes = *source_bytes;
+                }
+
+                __m512i simd_value;
+                while (end_address - destination_bytes >= 64) {
+                    destination_bytes -= 64;
+                    source_bytes -= 64;
+
+                    simd_value = _mm512_load_si512((__m512i*)source_bytes);
+                    _mm512_store_si512((__m512i*)destination, simd_value);
+                }
+            } else {
+                __m512i simd_value;
+                while (end_address - destination_bytes >= 64) {
+                    destination_bytes -= 64;
+                    source_bytes -= 64;
+
+                    simd_value = _mm512_loadu_si512((__m512i*)source_bytes);
+                    _mm512_storeu_si512((__m512i*)destination, simd_value);
+                }
+            }
+            break;
+        }
+
+        case HALLOCY_SIMD_AVX2:
+        case HALLOCY_SIMD_AVX: {
+            if ((size_t)destination_bytes % 32 == (size_t)source_bytes % 64) {
+                while (((size_t)destination_bytes % 32) != 0 && destination_bytes != end_address) {
+                    destination_bytes -= 1;
+                    source_bytes -= 1;
+
+                    *destination_bytes = *source_bytes;
+                }
+
+                __m256i simd_value;
+                while (end_address - destination_bytes >= 32) {
+                    destination_bytes -= 32;
+                    source_bytes -= 32;
+
+                    simd_value = _mm256_load_si256((__m256i*)source_bytes);
+                    _mm256_store_si256((__m256i*)destination, simd_value);
+                }
+            } else {
+                __m256i simd_value;
+                while (end_address - destination_bytes >= 32) {
+                    destination_bytes -= 32;
+                    source_bytes -= 32;
+
+                    simd_value = _mm256_loadu_si256((__m256i*)source_bytes);
+                    _mm256_storeu_si256((__m256i*)destination, simd_value);
+                }
+            }
+            break;
+        }
+
+        case HALLOCY_SIMD_SSE2:
+        case HALLOCY_SIMD_SSE: {
+            if ((size_t)destination_bytes % 16 == (size_t)source_bytes % 64) {
+                while (((size_t)destination_bytes % 16) != 0 && destination_bytes != end_address) {
+                    destination_bytes -= 1;
+                    source_bytes -= 1;
+                    *destination_bytes = *source_bytes;
+                }
+
+                __m128i simd_value;
+                while (end_address - destination_bytes >= 16) {
+                    destination_bytes -= 16;
+                    source_bytes -= 16;
+
+                    simd_value = _mm_load_si128((__m128i*)source_bytes);
+                    _mm_store_si128((__m128i*)destination, simd_value);
+                }
+            } else {
+                __m128i simd_value;
+                while (end_address - destination_bytes >= 16) {
+                    destination_bytes -= 16;
+                    source_bytes -= 16;
+
+                    simd_value = _mm_loadu_si128((__m128i*)source_bytes);
+                    _mm_storeu_si128((__m128i*)destination, simd_value);
+                }
+            }
+            break;
+        }
+        #endif
+        default: {
+            size_t word_size = sizeof(size_t);
+            if ((size_t)destination_bytes % word_size == (size_t)source_bytes % word_size) {
+                while (((size_t)destination_bytes % word_size) != 0 && destination_bytes != end_address) {
+                    destination_bytes -= 1;
+                    source_bytes -= 1;
+                    *destination_bytes = *source_bytes;
+                }
+
+                size_t *destination_word = (size_t*)destination_bytes;
+                size_t *source_word = (size_t*)source_bytes;
+                while ((unsigned char*)(destination_word - 1) > end_address) {
+                    destination_word -= 1;
+                    source_word -= 1;
+                    *destination_word = *source_word;
+                }
+
+                source_bytes = (unsigned char*)source_word;
+                destination_bytes = (unsigned char*)destination_word;
+            }
+
+            break;
+        }
+    }
+
+    while (destination_bytes != end_address) {
+        destination_bytes -= 1;
+        source_bytes -= 1;
+        *destination_bytes = *source_bytes;
+    }
+
     return HALLOCY_ERROR_NONE;
 }
\ No newline at end of file
diff --git a/Tests/Main.c b/Tests/Main.c
index 4967b57..09645e3 100644
--- a/Tests/Main.c
+++ b/Tests/Main.c
@@ -49,7 +49,14 @@
      printf("%s\n", text);
 
      char *text_copy = (char*)hallocy_malloc(36);
-     hallocy_copy_memory(text_copy, text, 36);
+     hallocy_copy_memory(text_copy, text, 35);
+     printf("%s\n", text_copy);
+
+     hallocy_set_memory(text_copy + 10, 'L', 25);
+     text_copy[14] = 'r';
+     text_copy[24] = 'r';
+     printf("%s\n", text_copy);
+     hallocy_move_memory(text_copy + 5, text_copy + 10, 15);
      printf("%s\n", text_copy);
 
      hallocy_free(text);