diff --git a/dist/googletest b/dist/googletest
index 3fbe4db9..2b6b042a 160000
--- a/dist/googletest
+++ b/dist/googletest
@@ -1 +1 @@
-Subproject commit 3fbe4db9a39291ae8d7a9c5f1d75896bb4c5a18f
+Subproject commit 2b6b042a77446ff322cd7522ca068d9f2a21c1d1
diff --git a/src/Emulator/Core/CPU/CPU.cpp b/src/Emulator/Core/CPU/CPU.cpp
index d22eb532..a979e7e5 100644
--- a/src/Emulator/Core/CPU/CPU.cpp
+++ b/src/Emulator/Core/CPU/CPU.cpp
@@ -1,16 +1,13 @@
 #include "Logger/Logger.hpp"
 #include <functional>
 
-#include <Core/MemoryController/MemoryControllerMT.hpp>
 #include <Core/MemoryController/MemoryControllerST.hpp>
 #include <Core/CPU/Decoders/IDecoder.hpp>
 #include <Core/CPU/Decoders/StdDecoder.hpp>
 #include <Core/CPU/CPU.hpp>
 
 HyperCPU::CPU::CPU(std::size_t core_count, std::size_t mem_size, char* binary, std::uint64_t binary_size) :
-  mem_controller(core_count == 1 ?
-    dynamic_cast<IMemoryController*>(new MemoryControllerST(mem_size, this)) : 
-    dynamic_cast<IMemoryController*>(new MemoryControllerMT(mem_size, this))),
+  mem_controller(dynamic_cast<IMemoryController*>(new MemoryControllerST(mem_size, this))),
   logger(LogLevel::ERROR),
   core_count(core_count),
   total_mem(mem_size),
diff --git a/src/Emulator/Core/CPU/CPU.hpp b/src/Emulator/Core/CPU/CPU.hpp
index 05243313..01c30869 100644
--- a/src/Emulator/Core/CPU/CPU.hpp
+++ b/src/Emulator/Core/CPU/CPU.hpp
@@ -23,7 +23,6 @@ namespace HyperCPU {
   using write_operation_handler = std::function<void(std::uint8_t)>;
 
   class MemoryControllerST;
-  class MemoryControllerMT;
 
   class CPU {
   private:
diff --git a/src/Emulator/Core/MemoryController/MemoryControllerMT.hpp b/src/Emulator/Core/MemoryController/MemoryControllerMT.hpp
deleted file mode 100644
index 14f33be8..00000000
--- a/src/Emulator/Core/MemoryController/MemoryControllerMT.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-#pragma once
-
-#include <cassert>
-#include <cstring>
-
-#include <stdexcept>
-#include <mutex>
-
-#include <Core/CPU/CPU.hpp>
-#include <Core/CPU/Interrupts/ReservedInterrupts.hpp>
-#include <Core/MemoryController/IMemoryController.hpp>
-
-
-namespace HyperCPU {
-  class MemoryControllerMT final : public IMemoryController {
-  private:
-    char* memory;
-    class CPU* cpu;
-    std::size_t total_mem;
-    std::mutex mutex;
-  
-  public:
-    explicit MemoryControllerMT(std::size_t mem_size, class CPU* cpu = nullptr) : cpu(cpu), total_mem(mem_size) {
-      memory = static_cast<char*>(calloc(total_mem, 1));
-      if (!memory)
-        throw std::runtime_error("Failed to allocate memory!");
-    }
-
-    inline std::uint8_t Fetch8(std::size_t& ptr) override {
-      mem_ctlr_assert(ptr + sizeof(std::uint8_t) - 1 < total_mem);
-      std::scoped_lock lock(mutex);
-      std::uint8_t data;
-      memcpy(&data, &memory[ptr], sizeof(std::uint8_t));
-      ptr += sizeof(std::uint8_t);
-      return data;
-    }
-
-    inline std::uint16_t Fetch16(std::size_t& ptr) override {
-      mem_ctlr_assert(ptr + sizeof(std::uint16_t) - 1 < total_mem);
-      std::scoped_lock lock(mutex);
-      std::uint16_t data;
-      memcpy(&data, &memory[ptr], sizeof(std::uint16_t));
-      ptr += sizeof(std::uint16_t);
-      return data;
-    }
-
-    inline std::uint32_t Fetch32(std::size_t& ptr) override {
-      mem_ctlr_assert(ptr + sizeof(std::uint32_t) - 1 < total_mem);
-      std::scoped_lock lock(mutex);
-      std::uint32_t data;
-      memcpy(&data, &memory[ptr], sizeof(std::uint32_t));
-      ptr += sizeof(std::uint32_t);
-      return data;
-    }
-
-    inline std::uint64_t Fetch64(std::size_t& ptr) override {
-      mem_ctlr_assert(ptr + sizeof(std::uint64_t) - 1 < total_mem);
-      std::scoped_lock lock(mutex);
-      std::uint64_t data;
-      memcpy(&data, &memory[ptr], sizeof(std::uint64_t));
-      ptr += sizeof(std::uint64_t);
-      return data;
-    }
-
-    inline std::uint8_t Read8(std::size_t ptr) override {
-      mem_ctlr_assert(ptr + sizeof(std::uint8_t) - 1 < total_mem);
-      std::scoped_lock lock(mutex);
-      std::uint8_t data;
-      memcpy(&data, &memory[ptr], sizeof(std::uint8_t));
-      return data;
-    }
-
-    inline std::uint16_t Read16(std::size_t ptr) override {
-      mem_ctlr_assert(ptr + sizeof(std::uint16_t) - 1 < total_mem);
-      std::scoped_lock lock(mutex);
-      std::uint16_t data;
-      memcpy(&data, &memory[ptr], sizeof(std::uint16_t));
-      return data;
-    }
-
-    inline std::uint32_t Read32(std::size_t ptr) override {
-      mem_ctlr_assert(ptr + sizeof(std::uint32_t) - 1 < total_mem);
-      std::scoped_lock lock(mutex);
-      std::uint32_t data;
-      memcpy(&data, &memory[ptr], sizeof(std::uint32_t));
-      return data;
-    }
-
-    inline std::uint64_t Read64(std::size_t ptr) override {
-      mem_ctlr_assert(ptr + sizeof(std::uint64_t) - 1 < total_mem);
-      std::scoped_lock lock(mutex);
-      std::uint64_t data;
-      memcpy(&data, &memory[ptr], sizeof(std::uint64_t));
-      return data;
-    }
-
-    inline void Load8(std::size_t ptr, std::uint8_t data) override {
-      mem_ctlr_assert(ptr + sizeof(std::uint8_t) - 1 < total_mem);
-      std::scoped_lock lock(mutex);
-      memcpy(&memory[ptr], &data, sizeof(std::uint8_t));
-    }
-
-    inline void Load16(std::size_t ptr, std::uint16_t data) override {
-      mem_ctlr_assert(ptr + sizeof(std::uint16_t) - 1 < total_mem);
-      std::scoped_lock lock(mutex);
-      memcpy(&memory[ptr], &data, sizeof(std::uint16_t));
-    }
-
-    inline void Load32(std::size_t ptr, std::uint32_t data) override {
-      mem_ctlr_assert(ptr + sizeof(std::uint32_t) - 1 < total_mem);
-      std::scoped_lock lock(mutex);
-      memcpy(&memory[ptr], &data, sizeof(std::uint32_t));
-    }
-
-    inline void Load64(std::size_t ptr, std::uint64_t data) override {
-      mem_ctlr_assert(ptr + sizeof(std::uint64_t) - 1 < total_mem);
-      std::scoped_lock lock(mutex);
-      memcpy(&memory[ptr], &data, sizeof(std::uint64_t));
-    }
-
-    std::uint8_t* get_ptr() const noexcept override { return reinterpret_cast<uint8_t*>(memory); }
-
-    ~MemoryControllerMT() {
-      free(memory);
-    }
-  };
-}
diff --git a/test/Modular/EmulatorCore/MemoryControllers/MT.cpp b/test/Modular/EmulatorCore/MemoryControllers/MT.cpp
deleted file mode 100644
index be3906e8..00000000
--- a/test/Modular/EmulatorCore/MemoryControllers/MT.cpp
+++ /dev/null
@@ -1,227 +0,0 @@
-#include <climits>
-#include <gtest/gtest.h>
-
-#include <fixtures.hpp>
-
-#define private public
-#include <Core/MemoryController/MemoryControllerMT.hpp>
-
-
-static constexpr std::uint8_t BYTE = 0x55;
-static constexpr std::uint16_t WORD = 0x5555;
-static constexpr std::uint32_t DWORD = 0x55555555;
-static constexpr std::uint64_t QWORD = 0x5555555555555555;
-
-TEST_F(MC_MT_TEST, LOAD8) {
-  for (std::size_t i = 0; i < MEM_FIXTURE_MEM_SIZE; i++, counter++)
-    mcmt.Load8(counter, BYTE);
-    
-  ASSERT_TRUE(std::memcmp(mcmt.memory,&tmp_buffer, MEM_FIXTURE_MEM_SIZE) == 0);
-}
-
-TEST_F(MC_MT_TEST, LOAD16) {
-  for (std::size_t i = 0; i < MEM_FIXTURE_MEM_SIZE / 2; ++i, counter += 2)
-    mcmt.Load16(counter, WORD);
-
-  ASSERT_TRUE(std::memcmp(mcmt.memory, tmp_buffer, MEM_FIXTURE_MEM_SIZE) == 0);
-}
-
-TEST_F(MC_MT_TEST, LOAD32) {
-  for (std::size_t i = 0; i < MEM_FIXTURE_MEM_SIZE / 4; ++i, counter += 4)
-    mcmt.Load32(counter, DWORD);
-
-  ASSERT_TRUE(std::memcmp(mcmt.memory, tmp_buffer, MEM_FIXTURE_MEM_SIZE) == 0);
-}
-
-TEST_F(MC_MT_TEST, LOAD64) {
-  for (std::size_t i = 0; i < MEM_FIXTURE_MEM_SIZE / 8; ++i, counter += 8)
-    mcmt.Load64(counter, QWORD);
-
-  ASSERT_TRUE(std::memcmp(mcmt.memory, tmp_buffer, MEM_FIXTURE_MEM_SIZE) == 0);
-}
-
-TEST_F(MC_MT_TEST, FETCH8) {
-  mcmt.Load64(counter, QWORD);
-
-  for (std::size_t i = 0; i < 8; ++i)
-    ASSERT_EQ(mcmt.Fetch8(counter), BYTE);
-}
-
-TEST_F(MC_MT_TEST, FETCH16) {
-  mcmt.Load64(counter, QWORD);
-
-  for (std::size_t i = 0; i < 4; ++i)
-    ASSERT_EQ(mcmt.Fetch16(counter), WORD);
-}
-
-TEST_F(MC_MT_TEST, FETCH32) {
-  mcmt.Load64(counter, QWORD);
-
-  for (std::size_t i = 0; i < 2; ++i)
-    ASSERT_EQ(mcmt.Fetch32(counter), DWORD);
-}
-
-TEST_F(MC_MT_TEST, FETCH64) {
-  mcmt.Load64(counter, QWORD);
-
-  ASSERT_EQ(mcmt.Fetch64(counter), QWORD);
-}
-
-TEST_F(MC_MT_TEST, READ8) {
-  mcmt.Load64(counter, QWORD);
-
-  for (std::size_t i = 0; i < 8; ++i, ++counter)
-    ASSERT_EQ(mcmt.Read8(counter), BYTE);
-}
-
-TEST_F(MC_MT_TEST, READ16) {
-  mcmt.Load64(counter, QWORD);
-
-  for (std::size_t i = 0; i < 4; ++i, counter += 2)
-    ASSERT_EQ(mcmt.Read16(counter), WORD);
-}
-
-TEST_F(MC_MT_TEST, READ32) {
-  mcmt.Load64(counter, QWORD);
-
-  for (std::size_t i = 0; i < 2; ++i, counter += 4)
-    ASSERT_EQ(mcmt.Read32(counter), DWORD);
-}
-
-TEST_F(MC_MT_TEST, READ64) {
-  mcmt.Load64(counter, QWORD);
-
-  ASSERT_EQ(mcmt.Read64(counter), QWORD);
-}
-
-TEST_F(MC_MT_FAILTEST, LOAD8) {
-  ASSERT_EXIT(mcmt.Load8(counter, BYTE), ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_FAILTEST, LOAD16) {
-  ASSERT_EXIT(mcmt.Load16(counter, WORD), ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_FAILTEST, LOAD32) {
-  ASSERT_EXIT(mcmt.Load32(counter, DWORD), ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_FAILTEST, LOAD64) {
-  ASSERT_EXIT(mcmt.Load64(counter, QWORD), ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_FAILTEST, FETCH8) {
-  ASSERT_EXIT(mcmt.Fetch8(counter), ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_FAILTEST, FETCH16) {
-  ASSERT_EXIT(mcmt.Fetch16(counter), ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_FAILTEST, FETCH32) {
-  ASSERT_EXIT(mcmt.Fetch32(counter), ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_FAILTEST, FETCH64) {
-  ASSERT_EXIT(mcmt.Fetch64(counter), ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_FAILTEST, READ8) {
-  ASSERT_EXIT(mcmt.Read8(counter), ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_FAILTEST, READ16) {
-  ASSERT_EXIT(mcmt.Read16(counter), ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_FAILTEST, READ32) {
-  ASSERT_EXIT(mcmt.Read32(counter), ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_FAILTEST, READ64) {
-  ASSERT_EXIT(mcmt.Read64(counter), ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_NEARFAILTEST, LOAD8) {
-  counter = 1023;
-  ASSERT_EXIT({mcmt.Load8(counter, BYTE); exit(0); }, ::testing::ExitedWithCode(0), "");
-  ++counter;
-  ASSERT_EXIT({mcmt.Load8(counter, BYTE); exit(0); }, ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_NEARFAILTEST, LOAD16) {
-  counter = 1022;
-  ASSERT_EXIT({mcmt.Load16(counter, WORD); exit(0); }, ::testing::ExitedWithCode(0), "");
-  counter = 1023;
-  ASSERT_EXIT({mcmt.Load16(counter, WORD); exit(0); }, ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_NEARFAILTEST, LOAD32) {
-  counter = 1020;
-  ASSERT_EXIT({mcmt.Load32(counter, DWORD); exit(0); }, ::testing::ExitedWithCode(0), "");
-  counter = 1021;
-  ASSERT_EXIT({mcmt.Load32(counter, DWORD); exit(0); }, ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_NEARFAILTEST, LOAD64) {
-  counter = 1016;
-  ASSERT_EXIT({mcmt.Load64(counter, QWORD); exit(0); }, ::testing::ExitedWithCode(0), "");
-  counter = 1017;
-  ASSERT_EXIT({mcmt.Load64(counter, QWORD); exit(0); }, ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_NEARFAILTEST, FETCH8) {
-  counter = 1023;
-  ASSERT_EXIT({mcmt.Fetch8(counter); exit(0); }, ::testing::ExitedWithCode(0), "");
-  counter = 1024;
-  ASSERT_EXIT({mcmt.Fetch8(counter); exit(0); }, ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_NEARFAILTEST, FETCH16) {
-  counter = 1022;
-  ASSERT_EXIT({mcmt.Fetch16(counter); exit(0); }, ::testing::ExitedWithCode(0), "");
-  counter = 1023;
-  ASSERT_EXIT({mcmt.Fetch16(counter); exit(0); }, ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_NEARFAILTEST, FETCH32) {
-  counter = 1020;
-  ASSERT_EXIT({mcmt.Fetch32(counter); exit(0); }, ::testing::ExitedWithCode(0), "");
-  counter = 1021;
-  ASSERT_EXIT({mcmt.Fetch32(counter); exit(0); }, ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_NEARFAILTEST, FETCH64) {
-  counter = 1016;
-  ASSERT_EXIT({mcmt.Fetch64(counter); exit(0); }, ::testing::ExitedWithCode(0), "");
-  counter = 1017;
-  ASSERT_EXIT({mcmt.Fetch64(counter); exit(0); }, ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_NEARFAILTEST, READ8) {
-  counter = 1023;
-  ASSERT_EXIT({mcmt.Read8(counter); exit(0); }, ::testing::ExitedWithCode(0), "");
-  counter = 1024;
-  ASSERT_EXIT({mcmt.Read8(counter); exit(0); }, ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_NEARFAILTEST, READ16) {
-  counter = 1022;
-  ASSERT_EXIT({mcmt.Read16(counter); exit(0); }, ::testing::ExitedWithCode(0), "");
-  counter = 1023;
-  ASSERT_EXIT({mcmt.Read16(counter); exit(0); }, ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_NEARFAILTEST, READ32) {
-  counter = 1020;
-  ASSERT_EXIT({mcmt.Read32(counter); exit(0); }, ::testing::ExitedWithCode(0), "");
-  counter = 1021;
-  ASSERT_EXIT({mcmt.Read32(counter); exit(0); }, ::testing::KilledBySignal(SIGABRT), "");
-}
-
-TEST_F(MC_MT_NEARFAILTEST, READ64) {
-  counter = 1016;
-  ASSERT_EXIT({mcmt.Read64(counter); exit(0); }, ::testing::ExitedWithCode(0), "");
-  counter = 1017;
-  ASSERT_EXIT({mcmt.Read64(counter); exit(0); }, ::testing::KilledBySignal(SIGABRT), "");
-}
\ No newline at end of file
diff --git a/test/fixtures.hpp b/test/fixtures.hpp
index 17a6dcad..6bbb1662 100644
--- a/test/fixtures.hpp
+++ b/test/fixtures.hpp
@@ -5,7 +5,6 @@
 #include <gtest/gtest.h>
 
 #define private public
-#include <Core/MemoryController/MemoryControllerMT.hpp>
 #include <Core/MemoryController/MemoryControllerST.hpp>
 #include <Core/CPU/Instructions/Registers.hpp>
 #include <Core/CPU/Instructions/Opcodes.hpp>
@@ -40,30 +39,6 @@ class TempDir {
   std::string dir_name;
 };
 
-class MC_MT_TEST : public testing::Test {
-  protected:
-    HyperCPU::MemoryControllerMT mcmt;
-    char tmp_buffer[MEM_FIXTURE_MEM_SIZE];
-    std::size_t counter;
-    MC_MT_TEST() : mcmt(MEM_FIXTURE_MEM_SIZE), counter(0) {
-      std::memset(tmp_buffer, 0x55, MEM_FIXTURE_MEM_SIZE);
-    }
-};
-
-class MC_MT_FAILTEST : public testing::Test {
-  protected:
-    HyperCPU::MemoryControllerMT mcmt;
-    std::size_t counter;
-    MC_MT_FAILTEST() : mcmt(MEM_FIXTURE_MEM_SIZE), counter(LONG_MAX) {}
-};
-
-class MC_MT_NEARFAILTEST : public testing::Test {
-  protected:
-    HyperCPU::MemoryControllerMT mcmt;
-    std::size_t counter;
-    MC_MT_NEARFAILTEST() : mcmt(MEM_FIXTURE_MEM_SIZE) {}
-};
-
 class MC_ST_TEST : public testing::Test {
   protected:
     HyperCPU::MemoryControllerST mcmt;