diff --git a/level_zero/core/source/global_teardown.cpp b/level_zero/core/source/global_teardown.cpp
index 8ed1144f99..a7d1391f1c 100644
--- a/level_zero/core/source/global_teardown.cpp
+++ b/level_zero/core/source/global_teardown.cpp
@@ -19,7 +19,9 @@ decltype(&zelLoaderTranslateHandle) loaderTranslateHandleFunc = nullptr;
 decltype(&zelSetDriverTeardown) setDriverTeardownFunc = nullptr;
 
 void globalDriverSetup() {
-    std::unique_ptr<NEO::OsLibrary> loaderLibrary = std::unique_ptr<NEO::OsLibrary>{NEO::OsLibrary::loadFunc("")};
+    NEO::OsLibraryCreateProperties loaderLibraryProperties("ze_loader.dll");
+    loaderLibraryProperties.performSelfLoad = true;
+    std::unique_ptr<NEO::OsLibrary> loaderLibrary = std::unique_ptr<NEO::OsLibrary>{NEO::OsLibrary::loadFunc(loaderLibraryProperties)};
     loaderTranslateHandleFunc = reinterpret_cast<decltype(&zelLoaderTranslateHandle)>(loaderLibrary->getProcAddress("zelLoaderTranslateHandle"));
     setDriverTeardownFunc = reinterpret_cast<decltype(&zelSetDriverTeardown)>(loaderLibrary->getProcAddress("zelSetDriverTeardown"));
 }
diff --git a/level_zero/core/test/unit_tests/sources/device/test_l0_device.cpp b/level_zero/core/test/unit_tests/sources/device/test_l0_device.cpp
index db9e767f1e..69ad2f2b87 100644
--- a/level_zero/core/test/unit_tests/sources/device/test_l0_device.cpp
+++ b/level_zero/core/test/unit_tests/sources/device/test_l0_device.cpp
@@ -6084,7 +6084,7 @@ struct RTASDeviceTest : public ::testing::Test {
         std::string getFullPath() override {
             return std::string();
         }
-        static OsLibrary *load(const std::string &name) {
+        static OsLibrary *load(const NEO::OsLibraryCreateProperties &properties) {
             if (failLibraryLoad) {
                 return nullptr;
             }
diff --git a/level_zero/core/test/unit_tests/sources/rtas/test_rtas.cpp b/level_zero/core/test/unit_tests/sources/rtas/test_rtas.cpp
index 23cbd52929..39888e030f 100644
--- a/level_zero/core/test/unit_tests/sources/rtas/test_rtas.cpp
+++ b/level_zero/core/test/unit_tests/sources/rtas/test_rtas.cpp
@@ -221,7 +221,7 @@ struct MockRTASOsLibrary : public OsLibrary {
     std::string getFullPath() override {
         return std::string();
     }
-    static OsLibrary *load(const std::string &name) {
+    static OsLibrary *load(const OsLibraryCreateProperties &properties) {
         if (mockLoad == true) {
             auto ptr = new (std::nothrow) MockRTASOsLibrary();
             return ptr;
@@ -264,7 +264,7 @@ TEST_F(RTASTest, GivenLibraryLoadsSymbolsAndUnderlyingFunctionsSucceedThenSucces
         std::string getFullPath() override {
             return std::string();
         }
-        static OsLibrary *load(const std::string &name) {
+        static OsLibrary *load(const OsLibraryCreateProperties &properties) {
             auto ptr = new (std::nothrow) MockSymbolsLoadedOsLibrary();
             return ptr;
         }
diff --git a/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.cpp b/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.cpp
index 2dbebd6c39..0731b47473 100644
--- a/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.cpp
+++ b/level_zero/sysman/source/shared/firmware_util/sysman_firmware_util_imp.cpp
@@ -208,8 +208,9 @@ FirmwareUtilImp::~FirmwareUtilImp() {
 FirmwareUtil *FirmwareUtil::create(uint16_t domain, uint8_t bus, uint8_t device, uint8_t function) {
     FirmwareUtilImp *pFwUtilImp = new FirmwareUtilImp(domain, bus, device, function);
     UNRECOVERABLE_IF(nullptr == pFwUtilImp);
-    NEO::OsLibrary::loadFlagsOverwrite = &FirmwareUtilImp::fwUtilLoadFlags;
-    pFwUtilImp->libraryHandle = NEO::OsLibrary::loadFunc(FirmwareUtilImp::fwUtilLibraryName);
+    NEO::OsLibraryCreateProperties properties(FirmwareUtilImp::fwUtilLibraryName);
+    properties.customLoadFlags = &FirmwareUtilImp::fwUtilLoadFlags;
+    pFwUtilImp->libraryHandle = NEO::OsLibrary::loadFunc(properties);
     if (pFwUtilImp->libraryHandle == nullptr || pFwUtilImp->loadEntryPoints() == false || pFwUtilImp->fwDeviceInit() != ZE_RESULT_SUCCESS) {
         if (nullptr != pFwUtilImp->libraryHandle) {
             delete pFwUtilImp->libraryHandle;
diff --git a/level_zero/sysman/test/unit_tests/sources/firmware_util/linux/test_fw_util_linux.cpp b/level_zero/sysman/test/unit_tests/sources/firmware_util/linux/test_fw_util_linux.cpp
index 5c649f8b68..38fb671667 100644
--- a/level_zero/sysman/test/unit_tests/sources/firmware_util/linux/test_fw_util_linux.cpp
+++ b/level_zero/sysman/test/unit_tests/sources/firmware_util/linux/test_fw_util_linux.cpp
@@ -34,8 +34,6 @@ TEST(FwUtilTest, GivenLibraryWasSetWhenCreatingFirmwareUtilInterfaceThenLibraryI
     VariableBackup<bool> dlOpenCalledBackup{&dlOpenCalled, false};
     VariableBackup<int> dlOpenFlagsBackup{&dlOpenFlags, 0};
 
-    auto flags = RTLD_LAZY;
-    NEO::OsLibrary::loadFlagsOverwrite = &flags;
     L0::Sysman::FirmwareUtil *pFwUtil = L0::Sysman::FirmwareUtil::create(0, 0, 0, 0);
     EXPECT_EQ(dlOpenCalled, true);
     EXPECT_EQ(dlOpenFlags, RTLD_LAZY);
diff --git a/level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h b/level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h
index 84ce9ea49e..421ad2623d 100644
--- a/level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h
+++ b/level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h
@@ -43,8 +43,6 @@ struct MockFwUtilInterface : public L0::Sysman::FirmwareUtil {
 struct MockFwUtilOsLibrary : public OsLibrary {
   public:
     static bool mockLoad;
-    MockFwUtilOsLibrary(const std::string &name, std::string *errorValue) {
-    }
     MockFwUtilOsLibrary() {}
     ~MockFwUtilOsLibrary() override = default;
     void *getProcAddress(const std::string &procName) override {
@@ -61,7 +59,7 @@ struct MockFwUtilOsLibrary : public OsLibrary {
     std::string getFullPath() override {
         return std::string();
     }
-    static OsLibrary *load(const std::string &name) {
+    static OsLibrary *load(const OsLibraryCreateProperties &properties) {
         if (mockLoad == true) {
             auto ptr = new (std::nothrow) MockFwUtilOsLibrary();
             return ptr;
diff --git a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp
index 06cc50923b..1ad9725e15 100644
--- a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp
+++ b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp
@@ -114,7 +114,7 @@ ze_result_t MetricEnumeration::loadMetricsDiscovery() {
     getMetricsDiscoveryFilename(libnames);
 
     for (auto &name : libnames) {
-        hMetricsDiscovery.reset(NEO::OsLibrary::loadFunc(name));
+        hMetricsDiscovery.reset(NEO::OsLibrary::loadFunc({name}));
 
         // Load exported functions.
         if (hMetricsDiscovery) {
diff --git a/level_zero/tools/source/metrics/metric_oa_query_imp.cpp b/level_zero/tools/source/metrics/metric_oa_query_imp.cpp
index 8d5a44b3d3..1a2ba4119e 100644
--- a/level_zero/tools/source/metrics/metric_oa_query_imp.cpp
+++ b/level_zero/tools/source/metrics/metric_oa_query_imp.cpp
@@ -179,7 +179,7 @@ void MetricsLibrary::release() {
 
 bool MetricsLibrary::load() {
     // Load library.
-    handle = NEO::OsLibrary::loadFunc(getFilename());
+    handle = NEO::OsLibrary::loadFunc({getFilename()});
 
     // Load exported functions.
     if (handle) {
diff --git a/level_zero/tools/source/sysman/firmware_util/firmware_util_imp.cpp b/level_zero/tools/source/sysman/firmware_util/firmware_util_imp.cpp
index d9f08db4c5..085afd958a 100644
--- a/level_zero/tools/source/sysman/firmware_util/firmware_util_imp.cpp
+++ b/level_zero/tools/source/sysman/firmware_util/firmware_util_imp.cpp
@@ -192,8 +192,9 @@ FirmwareUtilImp::~FirmwareUtilImp() {
 FirmwareUtil *FirmwareUtil::create(uint16_t domain, uint8_t bus, uint8_t device, uint8_t function) {
     FirmwareUtilImp *pFwUtilImp = new FirmwareUtilImp(domain, bus, device, function);
     UNRECOVERABLE_IF(nullptr == pFwUtilImp);
-    NEO::OsLibrary::loadFlagsOverwrite = &FirmwareUtilImp::fwUtilLoadFlags;
-    pFwUtilImp->libraryHandle = NEO::OsLibrary::loadFunc(FirmwareUtilImp::fwUtilLibraryName);
+    NEO::OsLibraryCreateProperties properties(FirmwareUtilImp::fwUtilLibraryName);
+    properties.customLoadFlags = &FirmwareUtilImp::fwUtilLoadFlags;
+    pFwUtilImp->libraryHandle = NEO::OsLibrary::loadFunc(properties);
     if (pFwUtilImp->libraryHandle == nullptr || pFwUtilImp->loadEntryPoints() == false || pFwUtilImp->fwDeviceInit() != ZE_RESULT_SUCCESS) {
         if (nullptr != pFwUtilImp->libraryHandle) {
             delete pFwUtilImp->libraryHandle;
diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_initialization.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_initialization.cpp
index b316d96431..618cefbe10 100644
--- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_initialization.cpp
+++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_initialization.cpp
@@ -20,7 +20,7 @@ namespace ult {
 
 class MockOsLibrary : public NEO::OsLibrary {
   public:
-    MockOsLibrary(const std::string &name, std::string *errorValue) {
+    MockOsLibrary() {
     }
 
     void *getProcAddress(const std::string &procName) override {
@@ -35,8 +35,8 @@ class MockOsLibrary : public NEO::OsLibrary {
         return std::string();
     }
 
-    static OsLibrary *load(const std::string &name) {
-        auto ptr = new (std::nothrow) MockOsLibrary(name, nullptr);
+    static OsLibrary *load(const OsLibraryCreateProperties &properties) {
+        auto ptr = new (std::nothrow) MockOsLibrary();
         if (ptr == nullptr) {
             return nullptr;
         }
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/firmware_util/linux/test_fw_util_linux.cpp b/level_zero/tools/test/unit_tests/sources/sysman/firmware_util/linux/test_fw_util_linux.cpp
index 5c649f8b68..38fb671667 100644
--- a/level_zero/tools/test/unit_tests/sources/sysman/firmware_util/linux/test_fw_util_linux.cpp
+++ b/level_zero/tools/test/unit_tests/sources/sysman/firmware_util/linux/test_fw_util_linux.cpp
@@ -34,8 +34,6 @@ TEST(FwUtilTest, GivenLibraryWasSetWhenCreatingFirmwareUtilInterfaceThenLibraryI
     VariableBackup<bool> dlOpenCalledBackup{&dlOpenCalled, false};
     VariableBackup<int> dlOpenFlagsBackup{&dlOpenFlags, 0};
 
-    auto flags = RTLD_LAZY;
-    NEO::OsLibrary::loadFlagsOverwrite = &flags;
     L0::Sysman::FirmwareUtil *pFwUtil = L0::Sysman::FirmwareUtil::create(0, 0, 0, 0);
     EXPECT_EQ(dlOpenCalled, true);
     EXPECT_EQ(dlOpenFlags, RTLD_LAZY);
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/firmware_util/mock_fw_util_fixture.h b/level_zero/tools/test/unit_tests/sources/sysman/firmware_util/mock_fw_util_fixture.h
index 7b6277f3d1..2cbde504f3 100644
--- a/level_zero/tools/test/unit_tests/sources/sysman/firmware_util/mock_fw_util_fixture.h
+++ b/level_zero/tools/test/unit_tests/sources/sysman/firmware_util/mock_fw_util_fixture.h
@@ -61,7 +61,7 @@ struct MockFwUtilOsLibrary : public OsLibrary {
     std::string getFullPath() override {
         return std::string();
     }
-    static OsLibrary *load(const std::string &name) {
+    static OsLibrary *load(const OsLibraryCreateProperties &properties) {
         if (mockLoad == true) {
             auto ptr = new (std::nothrow) MockFwUtilOsLibrary();
             return ptr;
diff --git a/opencl/source/sharings/gl/linux/gl_sharing_linux.cpp b/opencl/source/sharings/gl/linux/gl_sharing_linux.cpp
index 719fcc5794..f3cd5a1452 100644
--- a/opencl/source/sharings/gl/linux/gl_sharing_linux.cpp
+++ b/opencl/source/sharings/gl/linux/gl_sharing_linux.cpp
@@ -95,7 +95,7 @@ void GLSharingFunctionsLinux::removeGlArbSyncEventMapping(Event &baseEvent) {
 }
 
 GLboolean GLSharingFunctionsLinux::initGLFunctions() {
-    std::unique_ptr<OsLibrary> dynLibrary(OsLibrary::loadFunc(""));
+    std::unique_ptr<OsLibrary> dynLibrary(OsLibrary::loadFunc({""}));
 
     GlFunctionHelper glXGetProc(dynLibrary.get(), "glXGetProcAddress");
     if (glXGetProc.ready()) {
diff --git a/opencl/source/sharings/gl/windows/gl_sharing_windows.cpp b/opencl/source/sharings/gl/windows/gl_sharing_windows.cpp
index 11d45a0a02..fbc598e01d 100644
--- a/opencl/source/sharings/gl/windows/gl_sharing_windows.cpp
+++ b/opencl/source/sharings/gl/windows/gl_sharing_windows.cpp
@@ -29,7 +29,7 @@ GLSharingFunctionsWindows::~GLSharingFunctionsWindows() {
 }
 
 bool GLSharingFunctionsWindows::isGlSharingEnabled() {
-    static bool oglLibAvailable = std::unique_ptr<OsLibrary>(OsLibrary::loadFunc(Os::openglDllName)).get() != nullptr;
+    static bool oglLibAvailable = std::unique_ptr<OsLibrary>(OsLibrary::loadFunc({Os::openglDllName})).get() != nullptr;
     return oglLibAvailable;
 }
 
@@ -128,7 +128,7 @@ void GLSharingFunctionsWindows::removeGlArbSyncEventMapping(Event &baseEvent) {
 }
 
 GLboolean GLSharingFunctionsWindows::initGLFunctions() {
-    glLibrary.reset(OsLibrary::loadFunc(Os::openglDllName));
+    glLibrary.reset(OsLibrary::loadFunc({Os::openglDllName}));
 
     if (glLibrary->isLoaded()) {
         GlFunctionHelper wglLibrary(glLibrary.get(), "wglGetProcAddress");
diff --git a/opencl/test/unit_test/helpers/windows/gl_helper_tests.cpp b/opencl/test/unit_test/helpers/windows/gl_helper_tests.cpp
index 4441fee73f..818518bb43 100644
--- a/opencl/test/unit_test/helpers/windows/gl_helper_tests.cpp
+++ b/opencl/test/unit_test/helpers/windows/gl_helper_tests.cpp
@@ -26,7 +26,7 @@ class GlFunctionHelperMock : public GlFunctionHelper {
 };
 
 TEST(GlFunctionHelper, whenCreateGlFunctionHelperThenSetGlFunctionPtrToLoadAnotherFunctions) {
-    std::unique_ptr<OsLibrary> glLibrary(OsLibrary::loadFunc("mock_opengl32.dll"));
+    std::unique_ptr<OsLibrary> glLibrary(OsLibrary::loadFunc({"mock_opengl32.dll"}));
     EXPECT_TRUE(glLibrary->isLoaded());
     GlFunctionHelperMock loader(glLibrary.get(), "mockLoader");
     funcType function1 = ConvertibleProcAddr{reinterpret_cast<void *>(loader.glFunctionPtr("realFunction"))};
@@ -35,7 +35,7 @@ TEST(GlFunctionHelper, whenCreateGlFunctionHelperThenSetGlFunctionPtrToLoadAnoth
 }
 
 TEST(GlFunctionHelper, givenNonExistingFunctionNameWhenCreateGlFunctionHelperThenNullptr) {
-    std::unique_ptr<OsLibrary> glLibrary(OsLibrary::loadFunc("mock_opengl32.dll"));
+    std::unique_ptr<OsLibrary> glLibrary(OsLibrary::loadFunc({"mock_opengl32.dll"}));
     EXPECT_TRUE(glLibrary->isLoaded());
     GlFunctionHelper loader(glLibrary.get(), "mockLoader");
     funcType function = loader["nonExistingFunction"];
@@ -43,7 +43,7 @@ TEST(GlFunctionHelper, givenNonExistingFunctionNameWhenCreateGlFunctionHelperThe
 }
 
 TEST(GlFunctionHelper, givenRealFunctionNameWhenCreateGlFunctionHelperThenGetPointerToAppropriateFunction) {
-    std::unique_ptr<OsLibrary> glLibrary(OsLibrary::loadFunc("mock_opengl32.dll"));
+    std::unique_ptr<OsLibrary> glLibrary(OsLibrary::loadFunc({"mock_opengl32.dll"}));
     EXPECT_TRUE(glLibrary->isLoaded());
     GlFunctionHelper loader(glLibrary.get(), "mockLoader");
     funcType function = loader["realFunction"];
diff --git a/opencl/test/unit_test/sharings/gl/gl_dll_helper.h b/opencl/test/unit_test/sharings/gl/gl_dll_helper.h
index 48280cddcd..61e8b3950b 100644
--- a/opencl/test/unit_test/sharings/gl/gl_dll_helper.h
+++ b/opencl/test/unit_test/sharings/gl/gl_dll_helper.h
@@ -38,7 +38,7 @@ using setGLMockValue = void (*)(GLMockReturnedValues);
 struct GlDllHelper {
   public:
     GlDllHelper() {
-        glDllLoad.reset(OsLibrary::loadFunc(Os::openglDllName));
+        glDllLoad.reset(OsLibrary::loadFunc({Os::openglDllName}));
         if (glDllLoad) {
             glSetString = (*glDllLoad)["glSetString"];
             UNRECOVERABLE_IF(glSetString == nullptr);
diff --git a/shared/offline_compiler/source/decoder/iga_wrapper.cpp b/shared/offline_compiler/source/decoder/iga_wrapper.cpp
index 828e3c1357..465a3d13c0 100644
--- a/shared/offline_compiler/source/decoder/iga_wrapper.cpp
+++ b/shared/offline_compiler/source/decoder/iga_wrapper.cpp
@@ -42,7 +42,7 @@ struct IgaWrapper::Impl {
         iga.optsContext.cb = sizeof(igaLib.optsContext);
         iga.optsContext.gen = igaGen;
 
-        iga.library.reset(NEO::OsLibrary::loadFunc(Os::igaDllName));
+        iga.library.reset(NEO::OsLibrary::loadFunc({Os::igaDllName}));
         if (iga.library == nullptr) {
             return;
         }
diff --git a/shared/offline_compiler/source/ocloc_fcl_facade.cpp b/shared/offline_compiler/source/ocloc_fcl_facade.cpp
index f60d2fa935..3ded79f7e1 100644
--- a/shared/offline_compiler/source/ocloc_fcl_facade.cpp
+++ b/shared/offline_compiler/source/ocloc_fcl_facade.cpp
@@ -81,7 +81,7 @@ int OclocFclFacade::initialize(const HardwareInfo &hwInfo) {
 }
 
 std::unique_ptr<OsLibrary> OclocFclFacade::loadFclLibrary() const {
-    return std::unique_ptr<OsLibrary>{OsLibrary::loadFunc(Os::frontEndDllName)};
+    return std::unique_ptr<OsLibrary>{OsLibrary::loadFunc({Os::frontEndDllName})};
 }
 
 CIF::CreateCIFMainFunc_t OclocFclFacade::loadCreateFclMainFunction() const {
diff --git a/shared/offline_compiler/source/ocloc_igc_facade.cpp b/shared/offline_compiler/source/ocloc_igc_facade.cpp
index 34765527f5..4221385326 100644
--- a/shared/offline_compiler/source/ocloc_igc_facade.cpp
+++ b/shared/offline_compiler/source/ocloc_igc_facade.cpp
@@ -112,7 +112,7 @@ int OclocIgcFacade::initialize(const HardwareInfo &hwInfo) {
 }
 
 std::unique_ptr<OsLibrary> OclocIgcFacade::loadIgcLibrary() const {
-    return std::unique_ptr<OsLibrary>{OsLibrary::loadFunc(Os::igcDllName)};
+    return std::unique_ptr<OsLibrary>{OsLibrary::loadFunc({Os::igcDllName})};
 }
 
 CIF::CreateCIFMainFunc_t OclocIgcFacade::loadCreateIgcMainFunction() const {
diff --git a/shared/offline_compiler/source/utilities/windows/seh_exception.cpp b/shared/offline_compiler/source/utilities/windows/seh_exception.cpp
index 84814384d7..8d2715439a 100644
--- a/shared/offline_compiler/source/utilities/windows/seh_exception.cpp
+++ b/shared/offline_compiler/source/utilities/windows/seh_exception.cpp
@@ -88,7 +88,7 @@ void SehException::getCallStack(unsigned int code, struct _EXCEPTION_POINTERS *e
     DWORD displacement = 0;
     DWORD64 displacement64 = 0;
 
-    std::unique_ptr<NEO::OsLibrary> psApiLib(NEO::OsLibrary::loadFunc("psapi.dll"));
+    std::unique_ptr<NEO::OsLibrary> psApiLib(NEO::OsLibrary::loadFunc({"psapi.dll"}));
     auto getMappedFileName = reinterpret_cast<getMappedFileNameFunction>(psApiLib->getProcAddress("GetMappedFileNameA"));
 
     size_t callstackCounter = 0;
diff --git a/shared/source/compiler_interface/compiler_interface.inl b/shared/source/compiler_interface/compiler_interface.inl
index db0d79554a..2c7addc088 100644
--- a/shared/source/compiler_interface/compiler_interface.inl
+++ b/shared/source/compiler_interface/compiler_interface.inl
@@ -90,7 +90,9 @@ template <template <CIF::Version_t> class EntryPointT>
 inline bool loadCompiler(const char *libName, std::unique_ptr<OsLibrary> &outLib,
                          CIF::RAII::UPtr_t<CIF::CIFMain> &outLibMain) {
     std::string loadLibraryError;
-    auto lib = std::unique_ptr<OsLibrary>(OsLibrary::loadAndCaptureError(libName, &loadLibraryError));
+    OsLibraryCreateProperties libraryProperties(libName);
+    libraryProperties.errorValue = &loadLibraryError;
+    auto lib = std::unique_ptr<OsLibrary>(OsLibrary::loadFunc(libraryProperties));
     if (lib == nullptr) {
         NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Compiler Library %s could not be loaded with error: %s\n", libName, loadLibraryError.c_str());
         DEBUG_BREAK_IF(true); // could not load library
diff --git a/shared/source/os_interface/linux/os_library_linux.cpp b/shared/source/os_interface/linux/os_library_linux.cpp
index cf4848934c..6e783c477a 100644
--- a/shared/source/os_interface/linux/os_library_linux.cpp
+++ b/shared/source/os_interface/linux/os_library_linux.cpp
@@ -15,8 +15,8 @@
 
 namespace NEO {
 
-OsLibrary *OsLibrary::loadAndCaptureError(const std::string &name, std::string *errorValue) {
-    auto ptr = new (std::nothrow) Linux::OsLibrary(name, errorValue);
+OsLibrary *OsLibrary::load(const OsLibraryCreateProperties &properties) {
+    auto ptr = new (std::nothrow) Linux::OsLibrary(properties);
     if (ptr == nullptr)
         return nullptr;
 
@@ -33,8 +33,8 @@ const std::string OsLibrary::createFullSystemPath(const std::string &name) {
 
 namespace Linux {
 
-OsLibrary::OsLibrary(const std::string &name, std::string *errorValue) {
-    if (name.empty()) {
+OsLibrary::OsLibrary(const OsLibraryCreateProperties &properties) {
+    if (properties.libraryName.empty() || properties.performSelfLoad) {
         this->handle = SysCalls::dlopen(0, RTLD_LAZY);
     } else {
 #ifdef SANITIZER_BUILD
@@ -43,12 +43,11 @@ OsLibrary::OsLibrary(const std::string &name, std::string *errorValue) {
         auto dlopenFlag = RTLD_LAZY | RTLD_DEEPBIND;
         /* Background: https://github.com/intel/compute-runtime/issues/122 */
 #endif
-        dlopenFlag = OsLibrary::loadFlagsOverwrite ? *OsLibrary::loadFlagsOverwrite : dlopenFlag;
-        OsLibrary::loadFlagsOverwrite = nullptr;
+        dlopenFlag = properties.customLoadFlags ? *properties.customLoadFlags : dlopenFlag;
         adjustLibraryFlags(dlopenFlag);
-        this->handle = SysCalls::dlopen(name.c_str(), dlopenFlag);
-        if (!this->handle && (errorValue != nullptr)) {
-            errorValue->assign(dlerror());
+        this->handle = SysCalls::dlopen(properties.libraryName.c_str(), dlopenFlag);
+        if (!this->handle && (properties.errorValue != nullptr)) {
+            properties.errorValue->assign(dlerror());
         }
     }
 }
diff --git a/shared/source/os_interface/linux/os_library_linux.h b/shared/source/os_interface/linux/os_library_linux.h
index 3bf015fa3e..ff1473a32c 100644
--- a/shared/source/os_interface/linux/os_library_linux.h
+++ b/shared/source/os_interface/linux/os_library_linux.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2023 Intel Corporation
+ * Copyright (C) 2019-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -18,7 +18,7 @@ class OsLibrary : public NEO::OsLibrary {
     void *handle;
 
   public:
-    OsLibrary(const std::string &name, std::string *errorValue);
+    OsLibrary(const OsLibraryCreateProperties &properties);
     ~OsLibrary() override;
 
     bool isLoaded() override;
diff --git a/shared/source/os_interface/metrics_library.cpp b/shared/source/os_interface/metrics_library.cpp
index 8e4894e541..45fdac01d1 100644
--- a/shared/source/os_interface/metrics_library.cpp
+++ b/shared/source/os_interface/metrics_library.cpp
@@ -16,7 +16,7 @@ namespace NEO {
 ///////////////////////////////////////////////////////
 MetricsLibrary::MetricsLibrary() {
     api = std::make_unique<MetricsLibraryInterface>();
-    osLibrary.reset(OsLibrary::loadFunc(Os::metricsLibraryDllName));
+    osLibrary.reset(OsLibrary::loadFunc({Os::metricsLibraryDllName}));
 }
 
 //////////////////////////////////////////////////////
diff --git a/shared/source/os_interface/os_library.cpp b/shared/source/os_interface/os_library.cpp
index eeed34ede6..37218f18c2 100644
--- a/shared/source/os_interface/os_library.cpp
+++ b/shared/source/os_interface/os_library.cpp
@@ -8,8 +8,6 @@
 #include "shared/source/os_interface/os_library.h"
 namespace NEO {
 
-const int *OsLibrary::loadFlagsOverwrite = nullptr;
-
 decltype(&OsLibrary::load) OsLibrary::loadFunc = OsLibrary::load;
 
 } // namespace NEO
diff --git a/shared/source/os_interface/os_library.h b/shared/source/os_interface/os_library.h
index 28459a02b3..196f80d2d8 100644
--- a/shared/source/os_interface/os_library.h
+++ b/shared/source/os_interface/os_library.h
@@ -23,18 +23,25 @@ struct ConvertibleProcAddr {
     void *ptr = nullptr;
 };
 
+struct OsLibraryCreateProperties {
+    OsLibraryCreateProperties(std::string name) {
+        libraryName = name;
+    }
+    std::string libraryName;
+    std::string *errorValue = nullptr;
+    bool performSelfLoad = false;
+    int *customLoadFlags = nullptr;
+};
+
 class OsLibrary {
   protected:
     OsLibrary() = default;
-    static OsLibrary *load(const std::string &name) { return loadAndCaptureError(name, nullptr); }
+    static OsLibrary *load(const OsLibraryCreateProperties &properties);
 
   public:
     virtual ~OsLibrary() = default;
 
-    static const int *loadFlagsOverwrite;
-
     static decltype(&OsLibrary::load) loadFunc;
-    static OsLibrary *loadAndCaptureError(const std::string &name, std::string *errorValue);
     static const std::string createFullSystemPath(const std::string &name);
 
     ConvertibleProcAddr operator[](const std::string &name) {
diff --git a/shared/source/os_interface/windows/gmm_interface_win.cpp b/shared/source/os_interface/windows/gmm_interface_win.cpp
index 4615539454..3a39130aaa 100644
--- a/shared/source/os_interface/windows/gmm_interface_win.cpp
+++ b/shared/source/os_interface/windows/gmm_interface_win.cpp
@@ -19,7 +19,7 @@ namespace GmmInterface {
 
 GMM_STATUS initialize(GMM_INIT_IN_ARGS *pInArgs, GMM_INIT_OUT_ARGS *pOutArgs) {
     if (!gmmLib) {
-        gmmLib.reset(OsLibrary::loadFunc(GMM_UMD_DLL));
+        gmmLib.reset(OsLibrary::loadFunc({GMM_UMD_DLL}));
         UNRECOVERABLE_IF(!gmmLib);
     }
     auto initGmmFunc = reinterpret_cast<decltype(&InitializeGmm)>(gmmLib->getProcAddress(GMM_ADAPTER_INIT_NAME));
diff --git a/shared/source/os_interface/windows/os_library_win.cpp b/shared/source/os_interface/windows/os_library_win.cpp
index fab44538c5..81f0d5d04d 100644
--- a/shared/source/os_interface/windows/os_library_win.cpp
+++ b/shared/source/os_interface/windows/os_library_win.cpp
@@ -9,8 +9,8 @@
 
 namespace NEO {
 
-OsLibrary *OsLibrary::loadAndCaptureError(const std::string &name, std::string *errorValue) {
-    Windows::OsLibrary *ptr = new Windows::OsLibrary(name, errorValue);
+OsLibrary *OsLibrary::load(const OsLibraryCreateProperties &properties) {
+    Windows::OsLibrary *ptr = new Windows::OsLibrary(properties);
 
     if (!ptr->isLoaded()) {
         delete ptr;
@@ -30,9 +30,11 @@ const std::string OsLibrary::createFullSystemPath(const std::string &name) {
 }
 
 namespace Windows {
+decltype(&GetModuleHandleA) OsLibrary::getModuleHandleA = GetModuleHandleA;
 decltype(&LoadLibraryExA) OsLibrary::loadLibraryExA = LoadLibraryExA;
 decltype(&GetModuleFileNameA) OsLibrary::getModuleFileNameA = GetModuleFileNameA;
 decltype(&GetSystemDirectoryA) OsLibrary::getSystemDirectoryA = GetSystemDirectoryA;
+decltype(&FreeLibrary) OsLibrary::freeLibrary = FreeLibrary;
 
 extern "C" IMAGE_DOS_HEADER __ImageBase; // NOLINT(readability-identifier-naming)
 __inline HINSTANCE getModuleHINSTANCE() { return (HINSTANCE)&__ImageBase; }
@@ -66,23 +68,27 @@ HMODULE OsLibrary::loadDependency(const std::string &dependencyFileName) const {
     return loadLibraryExA(dllPath, NULL, 0);
 }
 
-OsLibrary::OsLibrary(const std::string &name, std::string *errorValue) {
-    if (name.empty()) {
-        this->handle = GetModuleHandleA(nullptr);
+OsLibrary::OsLibrary(const OsLibraryCreateProperties &properties) {
+    if (properties.libraryName.empty()) {
+        this->handle = getModuleHandleA(nullptr);
     } else {
-        this->handle = loadDependency(name);
-        if (this->handle == nullptr) {
-            this->handle = loadLibraryExA(name.c_str(), NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);
-            if ((this->handle == nullptr) && (errorValue != nullptr)) {
-                getLastErrorString(errorValue);
+        if (properties.performSelfLoad) {
+            this->handle = getModuleHandleA(properties.libraryName.c_str());
+        } else {
+            this->handle = loadDependency(properties.libraryName);
+            if (this->handle == nullptr) {
+                this->handle = loadLibraryExA(properties.libraryName.c_str(), NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);
             }
         }
+        if ((this->handle == nullptr) && (properties.errorValue != nullptr)) {
+            getLastErrorString(properties.errorValue);
+        }
     }
 }
 
 OsLibrary::~OsLibrary() {
-    if ((this->handle != nullptr) && (this->handle != GetModuleHandleA(nullptr))) {
-        ::FreeLibrary(this->handle);
+    if ((this->handle != nullptr) && (this->handle != getModuleHandleA(nullptr))) {
+        freeLibrary(this->handle);
         this->handle = nullptr;
     }
 }
diff --git a/shared/source/os_interface/windows/os_library_win.h b/shared/source/os_interface/windows/os_library_win.h
index 1e959b002a..f6aa438d54 100644
--- a/shared/source/os_interface/windows/os_library_win.h
+++ b/shared/source/os_interface/windows/os_library_win.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2023 Intel Corporation
+ * Copyright (C) 2019-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -20,7 +20,7 @@ class OsLibrary : public NEO::OsLibrary, NEO::NonCopyableOrMovableClass {
     HMODULE handle;
 
   public:
-    OsLibrary(const std::string &name, std::string *errorValue);
+    OsLibrary(const OsLibraryCreateProperties &properties);
     ~OsLibrary();
 
     bool isLoaded();
@@ -32,8 +32,10 @@ class OsLibrary : public NEO::OsLibrary, NEO::NonCopyableOrMovableClass {
   protected:
     HMODULE loadDependency(const std::string &dependencyFileName) const;
 
+    static decltype(&GetModuleHandleA) getModuleHandleA;
     static decltype(&LoadLibraryExA) loadLibraryExA;
     static decltype(&GetModuleFileNameA) getModuleFileNameA;
+    static decltype(&FreeLibrary) freeLibrary;
 };
 } // namespace Windows
 } // namespace NEO
diff --git a/shared/source/os_interface/windows/wddm/adapter_factory_dxcore.cpp b/shared/source/os_interface/windows/wddm/adapter_factory_dxcore.cpp
index 72b06ea24d..a6c90b6116 100644
--- a/shared/source/os_interface/windows/wddm/adapter_factory_dxcore.cpp
+++ b/shared/source/os_interface/windows/wddm/adapter_factory_dxcore.cpp
@@ -19,7 +19,7 @@ namespace NEO {
 
 DxCoreAdapterFactory::DxCoreAdapterFactory(AdapterFactory::CreateAdapterFactoryFcn createAdapterFactoryFcn) : createAdapterFactoryFcn(createAdapterFactoryFcn) {
     if (nullptr == createAdapterFactoryFcn) {
-        dxCoreLibrary.reset(OsLibrary::loadFunc(Os::dxcoreDllName));
+        dxCoreLibrary.reset(OsLibrary::loadFunc({Os::dxcoreDllName}));
         if (dxCoreLibrary && dxCoreLibrary->isLoaded()) {
             auto func = dxCoreLibrary->getProcAddress(dXCoreCreateAdapterFactoryFuncName);
             createAdapterFactoryFcn = reinterpret_cast<DxCoreAdapterFactory::CreateAdapterFactoryFcn>(func);
diff --git a/shared/source/pin/pin.cpp b/shared/source/pin/pin.cpp
index 60f2156c18..c65ca70cca 100644
--- a/shared/source/pin/pin.cpp
+++ b/shared/source/pin/pin.cpp
@@ -17,7 +17,7 @@
 namespace NEO {
 
 bool PinContext::init(const std::string &gtPinOpenFunctionName) {
-    auto hGtPinLibrary = std::unique_ptr<OsLibrary>(OsLibrary::loadFunc(PinContext::gtPinLibraryFilename.c_str()));
+    auto hGtPinLibrary = std::unique_ptr<OsLibrary>(OsLibrary::loadFunc({PinContext::gtPinLibraryFilename}));
 
     if (hGtPinLibrary == nullptr) {
         PRINT_DEBUG_STRING(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Unable to find gtpin library %s\n", PinContext::gtPinLibraryFilename.c_str());
diff --git a/shared/test/common/mocks/mock_os_library.h b/shared/test/common/mocks/mock_os_library.h
index 7729532a08..ed51eea802 100644
--- a/shared/test/common/mocks/mock_os_library.h
+++ b/shared/test/common/mocks/mock_os_library.h
@@ -35,7 +35,10 @@ class MockOsLibrary : public NEO::OsLibrary {
 
     static OsLibrary *loadLibraryNewObject;
 
-    static OsLibrary *load(const std::string &name) {
+    static OsLibrary *load(const NEO::OsLibraryCreateProperties &properties) {
+        if (properties.errorValue) {
+            return OsLibrary::load(properties);
+        }
         OsLibrary *ptr = loadLibraryNewObject;
         loadLibraryNewObject = nullptr;
         return ptr;
diff --git a/shared/test/common/os_interface/linux/sys_calls_linux_ult.cpp b/shared/test/common/os_interface/linux/sys_calls_linux_ult.cpp
index 334edbd83d..2bb06e24c5 100644
--- a/shared/test/common/os_interface/linux/sys_calls_linux_ult.cpp
+++ b/shared/test/common/os_interface/linux/sys_calls_linux_ult.cpp
@@ -107,6 +107,8 @@ int (*sysCallsGetDevicePath)(int deviceFd, char *buf, size_t &bufSize) = nullptr
 off_t lseekReturn = 4096u;
 std::atomic<int> lseekCalledCount(0);
 long sysconfReturn = 1ull << 30;
+std::string dlOpenFilePathPassed;
+bool captureDlOpenFilePath = false;
 
 int mkdir(const std::string &path) {
     if (sysCallsMkdir != nullptr) {
@@ -168,6 +170,13 @@ int openWithMode(const char *file, int flags, int mode) {
 void *dlopen(const char *filename, int flag) {
     dlOpenFlags = flag;
     dlOpenCalled = true;
+    if (captureDlOpenFilePath) {
+        if (filename) {
+            dlOpenFilePathPassed = filename;
+        } else {
+            dlOpenFilePathPassed = {};
+        }
+    }
     return ::dlopen(filename, flag);
 }
 
diff --git a/shared/test/common/os_interface/linux/sys_calls_linux_ult.h b/shared/test/common/os_interface/linux/sys_calls_linux_ult.h
index 7d8f78bdb1..392403b0b8 100644
--- a/shared/test/common/os_interface/linux/sys_calls_linux_ult.h
+++ b/shared/test/common/os_interface/linux/sys_calls_linux_ult.h
@@ -84,6 +84,8 @@ extern uint32_t munmapFuncCalled;
 
 extern off_t lseekReturn;
 extern std::atomic<int> lseekCalledCount;
+extern bool captureDlOpenFilePath;
+extern std::string dlOpenFilePathPassed;
 
 extern long sysconfReturn;
 } // namespace SysCalls
diff --git a/shared/test/unit_test/os_interface/linux/os_library_linux_tests.cpp b/shared/test/unit_test/os_interface/linux/os_library_linux_tests.cpp
index 1458e58bd7..eac3f486fb 100644
--- a/shared/test/unit_test/os_interface/linux/os_library_linux_tests.cpp
+++ b/shared/test/unit_test/os_interface/linux/os_library_linux_tests.cpp
@@ -34,14 +34,14 @@ TEST(OsLibraryTest, GivenValidNameWhenGettingFullPathAndDlinfoFailsThenPathIsEmp
         }
         return 0;
     });
-    std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc(Os::testDllName));
+    std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc({Os::testDllName}));
     EXPECT_NE(nullptr, library);
     std::string path = library->getFullPath();
     EXPECT_EQ(0u, path.size());
 }
 
 TEST(OsLibraryTest, GivenValidLibNameWhenGettingFullPathThenPathIsNotEmpty) {
-    std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc(Os::testDllName));
+    std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc({Os::testDllName}));
     EXPECT_NE(nullptr, library);
     std::string path = library->getFullPath();
     EXPECT_NE(0u, path.size());
@@ -59,7 +59,8 @@ TEST(OsLibraryTest, GivenDisableDeepBindFlagWhenOpeningLibraryThenRtldDeepBindFl
     VariableBackup<bool> dlOpenCalledBackup{&NEO::SysCalls::dlOpenCalled, false};
 
     debugManager.flags.DisableDeepBind.set(1);
-    auto lib = std::make_unique<Linux::OsLibrary>("_abc.so", nullptr);
+    OsLibraryCreateProperties properties("_abc.so");
+    auto lib = std::make_unique<Linux::OsLibrary>(properties);
     EXPECT_TRUE(NEO::SysCalls::dlOpenCalled);
     EXPECT_EQ(0, NEO::SysCalls::dlOpenFlags & RTLD_DEEPBIND);
 }
@@ -68,7 +69,9 @@ TEST(OsLibraryTest, GivenInvalidLibraryWhenOpeningLibraryThenDlopenErrorIsReturn
     VariableBackup<bool> dlOpenCalledBackup{&NEO::SysCalls::dlOpenCalled, false};
 
     std::string errorValue;
-    auto lib = std::make_unique<Linux::OsLibrary>("_abc.so", &errorValue);
+    OsLibraryCreateProperties properties("_abc.so");
+    properties.errorValue = &errorValue;
+    auto lib = std::make_unique<Linux::OsLibrary>(properties);
     EXPECT_FALSE(errorValue.empty());
     EXPECT_TRUE(NEO::SysCalls::dlOpenCalled);
 }
@@ -76,12 +79,33 @@ TEST(OsLibraryTest, GivenInvalidLibraryWhenOpeningLibraryThenDlopenErrorIsReturn
 TEST(OsLibraryTest, GivenLoadFlagsOverwriteWhenOpeningLibraryThenDlOpenIsCalledWithExpectedFlags) {
     VariableBackup<int> dlOpenFlagsBackup{&NEO::SysCalls::dlOpenFlags, 0};
     VariableBackup<bool> dlOpenCalledBackup{&NEO::SysCalls::dlOpenCalled, false};
+    VariableBackup<bool> dlOpenCaptureFileNameBackup{&NEO::SysCalls::captureDlOpenFilePath, true};
 
     auto expectedFlag = RTLD_LAZY | RTLD_GLOBAL;
-    NEO::OsLibrary::loadFlagsOverwrite = &expectedFlag;
-    auto lib = std::make_unique<Linux::OsLibrary>("_abc.so", nullptr);
+    OsLibraryCreateProperties properties("_abc.so");
+    properties.customLoadFlags = &expectedFlag;
+    auto lib = std::make_unique<Linux::OsLibrary>(properties);
     EXPECT_TRUE(NEO::SysCalls::dlOpenCalled);
     EXPECT_EQ(NEO::SysCalls::dlOpenFlags, expectedFlag);
+    EXPECT_EQ(properties.libraryName, NEO::SysCalls::dlOpenFilePathPassed);
+}
+
+TEST(OsLibraryTest, WhenPerformSelfOpenThenIgnoreFileNameForDlOpenCall) {
+    VariableBackup<bool> dlOpenCalledBackup{&NEO::SysCalls::dlOpenCalled, false};
+    VariableBackup<bool> dlOpenCaptureFileNameBackup{&NEO::SysCalls::captureDlOpenFilePath, true};
+
+    OsLibraryCreateProperties properties("_abc.so");
+    properties.performSelfLoad = false;
+    auto lib = std::make_unique<Linux::OsLibrary>(properties);
+    EXPECT_TRUE(NEO::SysCalls::dlOpenCalled);
+    EXPECT_EQ(properties.libraryName, NEO::SysCalls::dlOpenFilePathPassed);
+    NEO::SysCalls::dlOpenCalled = false;
+
+    properties.performSelfLoad = true;
+    lib = std::make_unique<Linux::OsLibrary>(properties);
+    EXPECT_TRUE(NEO::SysCalls::dlOpenCalled);
+    EXPECT_NE(properties.libraryName, NEO::SysCalls::dlOpenFilePathPassed);
+    EXPECT_TRUE(NEO::SysCalls::dlOpenFilePathPassed.empty());
 }
 
 } // namespace NEO
diff --git a/shared/test/unit_test/os_interface/os_library_tests.cpp b/shared/test/unit_test/os_interface/os_library_tests.cpp
index 7a6608fedd..cf880dbed8 100644
--- a/shared/test/unit_test/os_interface/os_library_tests.cpp
+++ b/shared/test/unit_test/os_interface/os_library_tests.cpp
@@ -22,7 +22,7 @@ const std::string fnName = "testDynamicLibraryFunc";
 using namespace NEO;
 
 TEST(OSLibraryTest, whenLibraryNameIsEmptyThenCurrentProcesIsUsedAsLibrary) {
-    std::unique_ptr<OsLibrary> library{OsLibrary::loadFunc("")};
+    std::unique_ptr<OsLibrary> library{OsLibrary::loadFunc({""})};
     EXPECT_NE(nullptr, library);
     void *ptr = library->getProcAddress("selfDynamicLibraryFunc");
     EXPECT_NE(nullptr, ptr);
@@ -35,32 +35,36 @@ TEST(OSLibraryTest, GivenFakeLibNameWhenLoadingLibraryThenNullIsReturned) {
 
 TEST(OSLibraryTest, GivenFakeLibNameWhenLoadingLibraryThenNullIsReturnedAndErrorString) {
     std::string errorValue;
-    OsLibrary *library = OsLibrary::loadAndCaptureError(fakeLibName, &errorValue);
+    OsLibraryCreateProperties properties(fakeLibName);
+    properties.errorValue = &errorValue;
+    OsLibrary *library = OsLibrary::loadFunc(properties);
     EXPECT_FALSE(errorValue.empty());
     EXPECT_EQ(nullptr, library);
 }
 
 TEST(OSLibraryTest, GivenValidLibNameWhenLoadingLibraryThenLibraryIsLoaded) {
-    std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc(Os::testDllName));
+    std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc({Os::testDllName}));
     EXPECT_NE(nullptr, library);
 }
 
 TEST(OSLibraryTest, GivenValidLibNameWhenLoadingLibraryThenLibraryIsLoadedWithNoErrorString) {
     std::string errorValue;
-    std::unique_ptr<OsLibrary> library(OsLibrary::loadAndCaptureError(Os::testDllName, &errorValue));
+    OsLibraryCreateProperties properties(Os::testDllName);
+    properties.errorValue = &errorValue;
+    std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc(properties));
     EXPECT_TRUE(errorValue.empty());
     EXPECT_NE(nullptr, library);
 }
 
 TEST(OSLibraryTest, whenSymbolNameIsValidThenGetProcAddressReturnsNonNullPointer) {
-    std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc(Os::testDllName));
+    std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc({Os::testDllName}));
     EXPECT_NE(nullptr, library);
     void *ptr = library->getProcAddress(fnName);
     EXPECT_NE(nullptr, ptr);
 }
 
 TEST(OSLibraryTest, whenSymbolNameIsInvalidThenGetProcAddressReturnsNullPointer) {
-    std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc(Os::testDllName));
+    std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc({Os::testDllName}));
     EXPECT_NE(nullptr, library);
     void *ptr = library->getProcAddress(fnName + "invalid");
     EXPECT_EQ(nullptr, ptr);
diff --git a/shared/test/unit_test/os_interface/windows/os_library_win_tests.cpp b/shared/test/unit_test/os_interface/windows/os_library_win_tests.cpp
index d920604844..aefa362760 100644
--- a/shared/test/unit_test/os_interface/windows/os_library_win_tests.cpp
+++ b/shared/test/unit_test/os_interface/windows/os_library_win_tests.cpp
@@ -20,6 +20,10 @@ extern const char *testDllName;
 using namespace NEO;
 
 class OsLibraryBackup : public Windows::OsLibrary {
+  public:
+    using Windows::OsLibrary::getModuleHandleA;
+    using Windows::OsLibrary::loadLibraryExA;
+
     using Type = decltype(Windows::OsLibrary::loadLibraryExA);
     using BackupType = VariableBackup<Type>;
 
@@ -35,7 +39,6 @@ class OsLibraryBackup : public Windows::OsLibrary {
         std::unique_ptr<SystemDirectoryBackupType> bkp3 = nullptr;
     };
 
-  public:
     static std::unique_ptr<Backup> backup(Type newValue, ModuleNameType newModuleName, SystemDirectoryType newSystemDirectoryName) {
         std::unique_ptr<Backup> bkp(new Backup());
         bkp->bkp1.reset(new BackupType(&OsLibrary::loadLibraryExA, newValue));
@@ -84,7 +87,7 @@ UINT WINAPI getSystemDirectoryAMock(LPSTR lpBuffer, UINT uSize) {
 TEST(OSLibraryWinTest, WhenLoadDependencyFailsThenFallbackToSystem32) {
     auto bkp = OsLibraryBackup::backup(loadLibraryExAMock, getModuleFileNameAMock, getSystemDirectoryAMock);
 
-    std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc(Os::testDllName));
+    std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc({Os::testDllName}));
     EXPECT_NE(nullptr, library);
 }
 
@@ -92,7 +95,7 @@ TEST(OSLibraryWinTest, WhenDependencyLoadsThenProperPathIsConstructed) {
     auto bkp = OsLibraryBackup::backup(loadLibraryExAMock, getModuleFileNameAMock, getSystemDirectoryAMock);
     VariableBackup<bool> bkpM(&mockWillFailInNonSystem32, false);
 
-    std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc(Os::testDllName));
+    std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc({Os::testDllName}));
     EXPECT_NE(nullptr, library);
 }
 
@@ -106,17 +109,41 @@ TEST(OSLibraryWinTest, WhenCreatingFullSystemPathThenProperPathIsConstructed) {
 
 TEST(OSLibraryWinTest, GivenInvalidLibraryWhenOpeningLibraryThenLoadLibraryErrorIsReturned) {
     std::string errorValue;
-    auto lib = std::make_unique<Windows::OsLibrary>("abc", &errorValue);
+    OsLibraryCreateProperties properties("abc");
+    properties.errorValue = &errorValue;
+    auto lib = std::make_unique<Windows::OsLibrary>(properties);
     EXPECT_FALSE(errorValue.empty());
 }
 
 TEST(OSLibraryWinTest, GivenNoLastErrorOnWindowsThenErrorStringisEmpty) {
     std::string errorValue;
 
-    auto lib = std::make_unique<Windows::OsLibrary>(Os::testDllName, &errorValue);
+    OsLibraryCreateProperties properties(Os::testDllName);
+    properties.errorValue = &errorValue;
+    auto lib = std::make_unique<Windows::OsLibrary>(properties);
     EXPECT_NE(nullptr, lib);
     EXPECT_TRUE(errorValue.empty());
     lib->getLastErrorString(&errorValue);
     EXPECT_TRUE(errorValue.empty());
     lib->getLastErrorString(nullptr);
 }
+
+TEST(OSLibraryWinTest, WhenCreateOsLibraryWithSelfOpenThenDontLoadLibrary) {
+    OsLibraryCreateProperties properties(Os::testDllName);
+    VariableBackup<decltype(OsLibraryBackup::loadLibraryExA)> backupLoadLibrary(&OsLibraryBackup::loadLibraryExA, [](LPCSTR, HANDLE, DWORD) -> HMODULE {
+        UNRECOVERABLE_IF(true);
+        return nullptr;
+    });
+
+    VariableBackup<decltype(OsLibraryBackup::getModuleHandleA)> backupGetModuleHandle(&OsLibraryBackup::getModuleHandleA, [](LPCSTR moduleName) -> HMODULE {
+        return nullptr;
+    });
+    properties.performSelfLoad = true;
+    auto lib = std::make_unique<Windows::OsLibrary>(properties);
+    EXPECT_FALSE(lib->isLoaded());
+    OsLibraryBackup::getModuleHandleA = [](LPCSTR moduleName) -> HMODULE {
+        return reinterpret_cast<HMODULE>(0x1000);
+    };
+    lib = std::make_unique<Windows::OsLibrary>(properties);
+    EXPECT_TRUE(lib->isLoaded());
+}
\ No newline at end of file