diff --git a/docs/docs/engines/engine-extension.mdx b/docs/docs/engines/engine-extension.mdx
index 8a62cd813..6bb966f60 100644
--- a/docs/docs/engines/engine-extension.mdx
+++ b/docs/docs/engines/engine-extension.mdx
@@ -1,89 +1,210 @@
 ---
-title: Building Engine Extensions
+title: Adding a Third-Party Engine to Cortex
 description: Cortex supports Engine Extensions to integrate both :ocal inference engines, and Remote APIs.
 ---
 
-:::info
-🚧 Cortex is currently under development, and this page is a stub for future development. 
-:::
-
-<!-- 
-import Tabs from "@theme/Tabs";
-import TabItem from "@theme/TabItem";
-
 :::warning
 🚧 Cortex.cpp is currently under development. Our documentation outlines the intended behavior of Cortex, which may not yet be fully implemented in the codebase.
 :::
 
+# Guide to Adding a Third-Party Engine to Cortex
+
+## Introduction
+
+This guide outlines the steps to integrate a custom engine with Cortex. We hope this helps developers understand the integration process.
+
+## Implementation Steps
+
+### 1. Implement the Engine Interface
+
+First, create an engine that implements the `EngineI.h` interface. Here's the interface definition:
+
+```cpp
+class EngineI {
+ public:
+  struct RegisterLibraryOption {
+    std::vector<std::filesystem::path> paths;
+  };
+
+  struct EngineLoadOption {
+    // engine
+    std::filesystem::path engine_path;
+    std::filesystem::path cuda_path;
+    bool custom_engine_path;
+
+    // logging
+    std::filesystem::path log_path;
+    int max_log_lines;
+    trantor::Logger::LogLevel log_level;
+  };
+
+  struct EngineUnloadOption {
+    bool unload_dll;
+  };
+
+  virtual ~EngineI() {}
 
-This document provides a step-by-step guide to adding a new engine to the Cortex codebase, similar to the `OpenAIEngineExtension`.
+  virtual void RegisterLibraryPath(RegisterLibraryOption opts) = 0;
 
+  virtual void Load(EngineLoadOption opts) = 0;
 
-## Integrate a New Remote Engine
+  virtual void Unload(EngineUnloadOption opts) = 0;
 
-### Step 1: Create the New Engine Extension
+  // Cortex.llamacpp interface methods
+  virtual void HandleChatCompletion(
+      std::shared_ptr<Json::Value> json_body,
+      std::function<void(Json::Value&&, Json::Value&&)>&& callback) = 0;
 
-1. Navigate to the `cortex-js/src/extensions` directory.
-2. Create a new file named `<new-engine>.engine.ts` (replace `<new-engine>` with the name of your engine).
-3. Implement your new engine extension class using the following template:
+  virtual void HandleEmbedding(
+      std::shared_ptr<Json::Value> json_body,
+      std::function<void(Json::Value&&, Json::Value&&)>&& callback) = 0;
 
-```typescript
-class <NewEngine>EngineExtension extends OAIEngineExtension {
-  apiUrl = 'https://api.<new-engine>.com/v1/chat/completions';
-  name = '<new-engine>';
-  productName = '<New Engine> Inference Engine';
-  description = 'This extension enables <New Engine> chat completion API calls';
-  version = '0.0.1';
-  apiKey?: string;
-}
+  virtual void LoadModel(
+      std::shared_ptr<Json::Value> json_body,
+      std::function<void(Json::Value&&, Json::Value&&)>&& callback) = 0;
+
+  virtual void UnloadModel(
+      std::shared_ptr<Json::Value> json_body,
+      std::function<void(Json::Value&&, Json::Value&&)>&& callback) = 0;
+
+  virtual void GetModelStatus(
+      std::shared_ptr<Json::Value> json_body,
+      std::function<void(Json::Value&&, Json::Value&&)>&& callback) = 0;
+
+  // Compatibility and model management
+  virtual bool IsSupported(const std::string& f) = 0;
+
+  virtual void GetModels(
+      std::shared_ptr<Json::Value> jsonBody,
+      std::function<void(Json::Value&&, Json::Value&&)>&& callback) = 0;
+
+  // Logging configuration
+  virtual bool SetFileLogger(int max_log_lines,
+                           const std::string& log_path) = 0;
+  virtual void SetLogLevel(trantor::Logger::LogLevel logLevel) = 0;
+};
 ```
 
-:::info
-Be sure to replace all placeholders with the appropriate values for your engine.
-:::
+#### Lifecycle Management
+
+##### RegisterLibraryPath
+
+```cpp
+virtual void RegisterLibraryPath(RegisterLibraryOption opts) = 0;
+```
+
+This method is called during engine initialization to set up dynamic library search paths. For example, in Linux, we still have to use `LD_LIBRARY_PATH` to add CUDA dependencies to the search path.
+
+**Parameters:**
+
+- `opts.paths`: Vector of filesystem paths that the engine should register
 
-### Step 2: Register the New Engine
+**Implementation Requirements:**
 
-1. Open the `extensions.module.ts` located at `cortex-js/src/extensions/`.
+- Register provided paths for dynamic library loading
+- Handle invalid paths gracefully
+- Thread-safe implementation
+- No exceptions should escape the method
 
-2. Register your new engine in the provider array using the following code:
+##### Load
 
-```typescript
-[
-    new OpenAIEngineExtension(httpService, configUsecases, eventEmitter),
-    //... other remote engines
-    new <NewEngine>EngineExtension(httpService, configUsecases, eventEmitter),
-]
+```cpp
+virtual void Load(EngineLoadOption opts) = 0;
 ```
 
-## Explanation of Key Properties and Methods
-| **Value**                   | **Description**                                                                                  |
-|------------------------------------|--------------------------------------------------------------------------------------------------|
-| `apiUrl`                           | This is the URL endpoint for the new engine's API. It is used to make chat completion requests.   |
-| `name`                             | This is a unique identifier for the engine. It is used internally to reference the engine.        |
-| `productName`                      | This is a human-readable name for the engine. It is used for display purposes.                    |
-| `description`                      | This provides a brief description of what the engine does. It is used for documentation and display purposes. |
-| `version`                          | This indicates the version of the engine extension. It is used for version control and display purposes. |
-| `eventEmmitter.on('config.updated')` | This is an event listener that listens for configuration updates. When the configuration for the engine is updated, this listener updates the `apiKey` and the engine's status. |
-| `onLoad`                           | This method is called when the engine extension is loaded. It retrieves the engine's configuration (such as the `apiKey`) and sets the engine's status based on whether the `apiKey` is available. |
+Initializes the engine with the provided configuration options.
 
-## Advanced: Transforming Payloads and Responses
+**Parameters:**
 
-Some engines require custom transformations for the payload sent to the API and the response received from the API. This is achieved using the `transformPayload` and `transformResponse` methods. These methods allow you to modify the data structure to match the specific requirements of the engine.
+- `engine_path`: Base path for engine files
+- `cuda_path`: Path to CUDA installation
+- `custom_engine_path`: Flag for using custom engine location
+- `log_path`: Location for log files
+- `max_log_lines`: Maximum number of lines per log file
+- `log_level`: Logging verbosity level
 
-### `transformPayload`
+**Implementation Requirements:**
+
+- Validate all paths before use
+- Initialize engine components
+- Set up logging configuration
+- Handle missing dependencies gracefully
+- Clean initialization state in case of failures
+
+##### Unload
+
+```cpp
+virtual void Unload(EngineUnloadOption opts) = 0;
+```
+
+Performs cleanup and shutdown of the engine.
+
+**Parameters:**
+
+- `unload_dll`: Boolean flag indicating whether to unload dynamic libraries
+
+**Implementation Requirements:**
+
+- Clean up all allocated resources
+- Close file handles and connections
+- Release memory
+- Ensure proper shutdown of running models
+- Handle cleanup in a thread-safe manner
+
+### 2. Create a Dynamic Library
+
+We recommend using the [dylib library](https://github.com/martin-olivier/dylib) to build your dynamic library. This library provides helpful tools for creating cross-platform dynamic libraries.
+
+### 3. Package Dependencies
+
+Please ensure all dependencies are included with your dynamic library. This allows us to create a single, self-contained package for distribution.
+
+### 4. Publication and Integration
+
+#### 4.1 Publishing Your Engine (Optional)
+
+If you wish to make your engine publicly available, you can publish it through GitHub. For reference, examine the [cortex.llamacpp releases](https://github.com/janhq/cortex.llamacpp/releases) structure:
+
+- Each release tag should represent your version
+- Include all variants within the same release
+- Cortex will automatically select the most suitable variant or allow users to specify their preferred variant
+
+#### 4.2 Integration with Cortex
+
+Once your engine is ready, we encourage you to:
+
+1. Notify the Cortex team about your engine for potential inclusion in our default supported engines list
+2. Allow us to help test and validate your implementation
+
+### 5. Local Testing Guide
+
+To test your engine locally:
+
+1. Create a directory structure following this hierarchy:
+
+```bash
+engines/
+└── cortex.llamacpp/
+    └── mac-arm64/
+        └── v0.1.40/
+            ├── libengine.dylib
+            └── version.txt
+```
 
-The `transformPayload` method is used to transform the data before sending it to the engine's API. This method takes the original payload and modifies it as needed.
+1. Configure your engine:
 
-**Example: Anthropic Engine**
+   - Edit the `~/.cortexrc` file to register your engine name
+   - Add your model with the appropriate engine field in `model.yaml`
 
-In the Anthropic Engine, the `transformPayload` method extracts the system message and other messages, and includes additional parameters like `model`, `stream`, and `max_tokens`.
+2. Testing:
+   - Start the engine
+   - Load your model
+   - Verify functionality
 
-### `transformResponse`
+## Future Development
 
-The `transformResponse` method is used to transform the data received from the engine's API. This method processes the response and converts it into a format that the application can use.
+We're currently working on expanding support for additional release sources to make distribution more flexible.
 
-**Example: Anthropic Engine**
+## Contributing
 
-In the Anthropic Engine, the `transformResponse` method handles both stream and non-stream responses. It processes the response data and converts it into a standardized format.
- -->
+We welcome suggestions and contributions to improve this integration process. Please feel free to submit issues or pull requests through our repository.
diff --git a/engine/cli/commands/server_start_cmd.cc b/engine/cli/commands/server_start_cmd.cc
index ba4f7bd82..3d52f3d25 100644
--- a/engine/cli/commands/server_start_cmd.cc
+++ b/engine/cli/commands/server_start_cmd.cc
@@ -1,9 +1,12 @@
 #include "server_start_cmd.h"
 #include "commands/cortex_upd_cmd.h"
+#include "services/engine_service.h"
 #include "utils/cortex_utils.h"
-#include "utils/engine_constants.h"
 #include "utils/file_manager_utils.h"
+
+#if defined(_WIN32) || defined(_WIN64)
 #include "utils/widechar_conv.h"
+#endif
 
 namespace commands {
 
@@ -108,22 +111,9 @@ bool ServerStartCmd::Exec(const std::string& host, int port,
     std::cerr << "Could not start server: " << std::endl;
     return false;
   } else if (pid == 0) {
-    // No need to configure LD_LIBRARY_PATH for macOS
-#if !defined(__APPLE__) || !defined(__MACH__)
-    const char* name = "LD_LIBRARY_PATH";
-    auto data = getenv(name);
-    std::string v;
-    if (auto g = getenv(name); g) {
-      v += g;
-    }
-    CTL_INF("LD_LIBRARY_PATH: " << v);
-    auto llamacpp_path = file_manager_utils::GetCudaToolkitPath(kLlamaRepo);
-    auto trt_path = file_manager_utils::GetCudaToolkitPath(kTrtLlmRepo);
+    // Some engines requires to add lib search path before process being created
+    EngineService().RegisterEngineLibPath();
 
-    auto new_v = trt_path.string() + ":" + llamacpp_path.string() + ":" + v;
-    setenv(name, new_v.c_str(), true);
-    CTL_INF("LD_LIBRARY_PATH: " << getenv(name));
-#endif
     std::string p = cortex_utils::GetCurrentPath() + "/" + exe;
     execl(p.c_str(), exe.c_str(), "--start-server", "--config_file_path",
           get_config_file_path().c_str(), "--data_folder_path",
diff --git a/engine/controllers/engines.cc b/engine/controllers/engines.cc
index 3d3c0c037..1d0223d9a 100644
--- a/engine/controllers/engines.cc
+++ b/engine/controllers/engines.cc
@@ -23,10 +23,9 @@ std::string NormalizeEngine(const std::string& engine) {
 void Engines::ListEngine(
     const HttpRequestPtr& req,
     std::function<void(const HttpResponsePtr&)>&& callback) const {
-  std::vector<std::string> supported_engines{kLlamaEngine, kOnnxEngine,
-                                             kTrtLlmEngine};
   Json::Value ret;
-  for (const auto& engine : supported_engines) {
+  auto engine_names = engine_service_->GetSupportedEngineNames().value();
+  for (const auto& engine : engine_names) {
     auto installed_engines =
         engine_service_->GetInstalledEngineVariants(engine);
     if (installed_engines.has_error()) {
diff --git a/engine/cortex-common/EngineI.h b/engine/cortex-common/EngineI.h
index 51e19c124..11866a708 100644
--- a/engine/cortex-common/EngineI.h
+++ b/engine/cortex-common/EngineI.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <filesystem>
 #include <functional>
 #include <memory>
 
@@ -7,8 +8,37 @@
 #include "trantor/utils/Logger.h"
 class EngineI {
  public:
+  struct RegisterLibraryOption {
+    std::vector<std::filesystem::path> paths;
+  };
+
+  struct EngineLoadOption {
+    // engine
+    std::filesystem::path engine_path;
+    std::filesystem::path cuda_path;
+    bool custom_engine_path;
+
+    // logging
+    std::filesystem::path log_path;
+    int max_log_lines;
+    trantor::Logger::LogLevel log_level;
+  };
+
+  struct EngineUnloadOption {
+    bool unload_dll;
+  };
+
   virtual ~EngineI() {}
 
+  /**
+   * Being called before starting process to register dependencies search paths.
+   */
+  virtual void RegisterLibraryPath(RegisterLibraryOption opts) = 0;
+
+  virtual void Load(EngineLoadOption opts) = 0;
+
+  virtual void Unload(EngineUnloadOption opts) = 0;
+
   // cortex.llamacpp interface
   virtual void HandleChatCompletion(
       std::shared_ptr<Json::Value> json_body,
diff --git a/engine/services/engine_service.cc b/engine/services/engine_service.cc
index fe5317c7d..4f2122f6b 100644
--- a/engine/services/engine_service.cc
+++ b/engine/services/engine_service.cc
@@ -2,6 +2,7 @@
 #include <cstdlib>
 #include <filesystem>
 #include <optional>
+#include <utility>
 #include <vector>
 #include "algorithm"
 #include "database/engines.h"
@@ -17,6 +18,7 @@
 #include "utils/semantic_version_utils.h"
 #include "utils/system_info_utils.h"
 #include "utils/url_parser.h"
+
 namespace {
 std::string GetSuitableCudaVersion(const std::string& engine,
                                    const std::string& cuda_driver_version) {
@@ -701,6 +703,87 @@ cpp::result<void, std::string> EngineService::LoadEngine(
 
   CTL_INF("Loading engine: " << ne);
 
+  auto engine_dir_path_res = GetEngineDirPath(ne);
+  if (engine_dir_path_res.has_error()) {
+    return cpp::fail(engine_dir_path_res.error());
+  }
+  auto engine_dir_path = engine_dir_path_res.value().first;
+  auto custom_engine_path = engine_dir_path_res.value().second;
+
+  try {
+    auto dylib =
+        std::make_unique<cortex_cpp::dylib>(engine_dir_path.string(), "engine");
+
+    auto config = file_manager_utils::GetCortexConfig();
+
+    auto log_path =
+        std::filesystem::path(config.logFolderPath) /
+        std::filesystem::path(
+            config.logLlamaCppPath);  // for now seems like we use same log path
+
+    // init
+    auto func = dylib->get_function<EngineI*()>("get_engine");
+    auto engine_obj = func();
+    auto load_opts = EngineI::EngineLoadOption{
+        .engine_path = engine_dir_path,
+        .cuda_path = file_manager_utils::GetCudaToolkitPath(ne),
+        .custom_engine_path = custom_engine_path,
+        .log_path = log_path,
+        .max_log_lines = config.maxLogLines,
+        .log_level = logging_utils_helper::global_log_level,
+    };
+    engine_obj->Load(load_opts);
+
+    engines_[ne].engine = engine_obj;
+    engines_[ne].dl = std::move(dylib);
+
+    CTL_DBG("Engine loaded: " << ne);
+    return {};
+  } catch (const cortex_cpp::dylib::load_error& e) {
+    CTL_ERR("Could not load engine: " << e.what());
+    engines_.erase(ne);
+    return cpp::fail("Could not load engine " + ne + ": " + e.what());
+  }
+}
+
+void EngineService::RegisterEngineLibPath() {
+  auto engine_names = GetSupportedEngineNames().value();
+  for (const auto& engine : engine_names) {
+    auto ne = NormalizeEngine(engine);
+    try {
+      auto engine_dir_path_res = GetEngineDirPath(engine);
+      if (engine_dir_path_res.has_error()) {
+        CTL_ERR(
+            "Could not get engine dir path: " << engine_dir_path_res.error());
+        continue;
+      }
+      auto engine_dir_path = engine_dir_path_res.value().first;
+      auto custom_engine_path = engine_dir_path_res.value().second;
+
+      auto dylib = std::make_unique<cortex_cpp::dylib>(engine_dir_path.string(),
+                                                       "engine");
+
+      auto cuda_path = file_manager_utils::GetCudaToolkitPath(ne);
+      // init
+      auto func = dylib->get_function<EngineI*()>("get_engine");
+      auto engine = func();
+      std::vector<std::filesystem::path> paths{};
+      auto register_opts = EngineI::RegisterLibraryOption{
+          .paths = paths,
+      };
+      engine->RegisterLibraryPath(register_opts);
+      delete engine;
+      CTL_DBG("Register lib path for: " << engine);
+    } catch (const std::exception& e) {
+      CTL_WRN("Failed to registering engine lib path: " << e.what());
+    }
+  }
+}
+
+cpp::result<std::pair<std::filesystem::path, bool>, std::string>
+EngineService::GetEngineDirPath(const std::string& engine_name) {
+  auto ne = NormalizeEngine(engine_name);
+
   auto selected_engine_variant = GetDefaultEngineVariant(ne);
 
   if (selected_engine_variant.has_error()) {
@@ -715,6 +798,7 @@ cpp::result<void, std::string> EngineService::LoadEngine(
   auto user_defined_engine_path = getenv("ENGINE_PATH");
 #endif
 
+  auto custom_engine_path = user_defined_engine_path != nullptr;
   CTL_DBG("user defined engine path: " << user_defined_engine_path);
   const std::filesystem::path engine_dir_path = [&] {
     if (user_defined_engine_path != nullptr) {
@@ -728,157 +812,38 @@ cpp::result<void, std::string> EngineService::LoadEngine(
     }
   }();
 
-  CTL_DBG("Engine path: " << engine_dir_path.string());
-
   if (!std::filesystem::exists(engine_dir_path)) {
     CTL_ERR("Directory " + engine_dir_path.string() + " is not exist!");
     return cpp::fail("Directory " + engine_dir_path.string() +
                      " is not exist!");
   }
 
-  CTL_INF("Engine path: " << engine_dir_path.string());
-
-  try {
-#if defined(_WIN32)
-    // TODO(?) If we only allow to load an engine at a time, the logic is simpler.
-    // We would like to support running multiple engines at the same time. Therefore,
-    // the adding/removing dll directory logic is quite complicated:
-    // 1. If llamacpp is loaded and new requested engine is tensorrt-llm:
-    // Unload the llamacpp dll directory then load the tensorrt-llm
-    // 2. If tensorrt-llm is loaded and new requested engine is llamacpp:
-    // Do nothing, llamacpp can re-use tensorrt-llm dependencies (need to be tested careful)
-    // 3. Add dll directory if met other conditions
-
-    auto add_dll = [this](const std::string& e_type,
-                          const std::filesystem::path& p) {
-      if (auto cookie = AddDllDirectory(p.c_str()); cookie != 0) {
-        CTL_DBG("Added dll directory: " << p.string());
-        engines_[e_type].cookie = cookie;
-      } else {
-        CTL_WRN("Could not add dll directory: " << p.string());
-      }
-
-      auto cuda_path = file_manager_utils::GetCudaToolkitPath(e_type);
-      if (auto cuda_cookie = AddDllDirectory(cuda_path.c_str());
-          cuda_cookie != 0) {
-        CTL_DBG("Added cuda dll directory: " << p.string());
-        engines_[e_type].cuda_cookie = cuda_cookie;
-      } else {
-        CTL_WRN("Could not add cuda dll directory: " << p.string());
-      }
-    };
-
-#if defined(_WIN32)
-    if (bool should_use_dll_search_path = !(_wgetenv(L"ENGINE_PATH"));
-#else
-    if (bool should_use_dll_search_path = !(getenv("ENGINE_PATH"));
-#endif
-        should_use_dll_search_path) {
-      if (IsEngineLoaded(kLlamaRepo) && ne == kTrtLlmRepo &&
-          should_use_dll_search_path) {
-
-        {
-
-          // Remove llamacpp dll directory
-          if (!RemoveDllDirectory(engines_[kLlamaRepo].cookie)) {
-            CTL_WRN("Could not remove dll directory: " << kLlamaRepo);
-          } else {
-            CTL_DBG("Removed dll directory: " << kLlamaRepo);
-          }
-          if (!RemoveDllDirectory(engines_[kLlamaRepo].cuda_cookie)) {
-            CTL_WRN("Could not remove cuda dll directory: " << kLlamaRepo);
-          } else {
-            CTL_DBG("Removed cuda dll directory: " << kLlamaRepo);
-          }
-        }
-
-        add_dll(ne, engine_dir_path);
-      } else if (IsEngineLoaded(kTrtLlmRepo) && ne == kLlamaRepo) {
-        // Do nothing
-      } else {
-        add_dll(ne, engine_dir_path);
-      }
-    }
-#endif
-    engines_[ne].dl =
-        std::make_unique<cortex_cpp::dylib>(engine_dir_path.string(), "engine");
-#if defined(__linux__)
-    const char* name = "LD_LIBRARY_PATH";
-    auto data = getenv(name);
-    std::string v;
-    if (auto g = getenv(name); g) {
-      v += g;
-    }
-    CTL_INF("LD_LIBRARY_PATH: " << v);
-    auto llamacpp_path = file_manager_utils::GetCudaToolkitPath(kLlamaRepo);
-    CTL_INF("llamacpp_path: " << llamacpp_path);
-    // tensorrt is not supported for now
-    // auto trt_path = file_manager_utils::GetCudaToolkitPath(kTrtLlmRepo);
-
-    auto new_v = llamacpp_path.string() + ":" + v;
-    setenv(name, new_v.c_str(), true);
-    CTL_INF("LD_LIBRARY_PATH: " << getenv(name));
-#endif
-
-  } catch (const cortex_cpp::dylib::load_error& e) {
-    CTL_ERR("Could not load engine: " << e.what());
-    engines_.erase(ne);
-    return cpp::fail("Could not load engine " + ne + ": " + e.what());
-  }
-
-  auto func = engines_[ne].dl->get_function<EngineI*()>("get_engine");
-  engines_[ne].engine = func();
-
-  auto& en = std::get<EngineI*>(engines_[ne].engine);
-  if (ne == kLlamaRepo) {  //fix for llamacpp engine first
-    auto config = file_manager_utils::GetCortexConfig();
-    if (en->IsSupported("SetFileLogger")) {
-      en->SetFileLogger(config.maxLogLines,
-                        (std::filesystem::path(config.logFolderPath) /
-                         std::filesystem::path(config.logLlamaCppPath))
-                            .string());
-    } else {
-      CTL_WRN("Method SetFileLogger is not supported yet");
-    }
-    if (en->IsSupported("SetLogLevel")) {
-      en->SetLogLevel(logging_utils_helper::global_log_level);
-    } else {
-      CTL_WRN("Method SetLogLevel is not supported yet");
-    }
-  }
-  CTL_DBG("loaded engine: " << ne);
-  return {};
+  CTL_INF("Engine path: " << engine_dir_path.string()
+                          << ", custom_engine_path: " << custom_engine_path);
+  return std::make_pair(engine_dir_path, custom_engine_path);
 }
 
 cpp::result<void, std::string> EngineService::UnloadEngine(
     const std::string& engine) {
   auto ne = NormalizeEngine(engine);
   std::lock_guard<std::mutex> lock(engines_mutex_);
-  {
-    if (!IsEngineLoaded(ne)) {
-      return cpp::fail("Engine " + ne + " is not loaded yet!");
-    }
-    if (std::holds_alternative<EngineI*>(engines_[ne].engine)) {
-      delete std::get<EngineI*>(engines_[ne].engine);
-    } else {
-      delete std::get<RemoteEngineI*>(engines_[ne].engine);
-    }
-
-#if defined(_WIN32)
-    if (!RemoveDllDirectory(engines_[ne].cookie)) {
-      CTL_WRN("Could not remove dll directory: " << ne);
-    } else {
-      CTL_DBG("Removed dll directory: " << ne);
-    }
-    if (!RemoveDllDirectory(engines_[ne].cuda_cookie)) {
-      CTL_WRN("Could not remove cuda dll directory: " << ne);
-    } else {
-      CTL_DBG("Removed cuda dll directory: " << ne);
-    }
-#endif
+  if (!IsEngineLoaded(ne)) {
+    return cpp::fail("Engine " + ne + " is not loaded yet!");
+  }
+  if (std::holds_alternative<EngineI*>(engines_[ne].engine)) {
+    LOG_INFO << "Unloading engine " << ne;
+    auto* e = std::get<EngineI*>(engines_[ne].engine);
+    auto unload_opts = EngineI::EngineUnloadOption{
+        .unload_dll = true,
+    };
+    e->Unload(unload_opts);
+    delete e;
     engines_.erase(ne);
+  } else {
+    delete std::get<RemoteEngineI*>(engines_[ne].engine);
   }
-  CTL_DBG("Unloaded engine " + ne);
+
+  CTL_DBG("Engine unloaded: " + ne);
   return {};
 }
 
@@ -1097,4 +1062,9 @@ cpp::result<Json::Value, std::string> EngineService::GetRemoteModels(
   } else {
     return res;
   }
-}
\ No newline at end of file
+}
+
+cpp::result<std::vector<std::string>, std::string>
+EngineService::GetSupportedEngineNames() {
+  return file_manager_utils::GetCortexConfig().supportedEngines;
+}
diff --git a/engine/services/engine_service.h b/engine/services/engine_service.h
index ab274825d..8299655f2 100644
--- a/engine/services/engine_service.h
+++ b/engine/services/engine_service.h
@@ -13,7 +13,6 @@
 #include "cortex-common/cortexpythoni.h"
 #include "cortex-common/remote_enginei.h"
 #include "database/engines.h"
-#include "extensions/remote-engine/remote_engine.h"
 #include "services/download_service.h"
 #include "utils/cpuid/cpu_info.h"
 #include "utils/dylib.h"
@@ -75,6 +74,9 @@ class EngineService : public EngineServiceI {
                 .cuda_driver_version =
                     system_info_utils::GetDriverAndCudaVersion().second} {}
 
+  // just for initialize supported engines
+  EngineService() {};
+
   std::vector<EngineInfo> GetEngineInfoList() const;
 
   /**
@@ -148,6 +150,9 @@ class EngineService : public EngineServiceI {
 
   cpp::result<Json::Value, std::string> GetRemoteModels(
       const std::string& engine_name);
+  cpp::result<std::vector<std::string>, std::string> GetSupportedEngineNames();
+
+  void RegisterEngineLibPath();
 
  private:
   bool IsEngineLoaded(const std::string& engine);
@@ -162,7 +167,10 @@ class EngineService : public EngineServiceI {
   std::string GetMatchedVariant(const std::string& engine,
                                 const std::vector<std::string>& variants);
 
+  cpp::result<std::pair<std::filesystem::path, bool>, std::string>
+  GetEngineDirPath(const std::string& engine_name);
+
   cpp::result<bool, std::string> IsEngineVariantReady(
       const std::string& engine, const std::string& version,
       const std::string& variant);
-};
\ No newline at end of file
+};
diff --git a/engine/services/hardware_service.cc b/engine/services/hardware_service.cc
index 25be78873..97ddacb97 100644
--- a/engine/services/hardware_service.cc
+++ b/engine/services/hardware_service.cc
@@ -5,11 +5,11 @@
 #if defined(_WIN32) || defined(_WIN64)
 #include <minwindef.h>
 #include <processenv.h>
+#include "utils/widechar_conv.h"
 #endif
 #include "cli/commands/cortex_upd_cmd.h"
 #include "database/hardware.h"
 #include "utils/cortex_utils.h"
-#include "utils/widechar_conv.h"
 
 namespace services {
 
diff --git a/engine/utils/config_yaml_utils.cc b/engine/utils/config_yaml_utils.cc
index ed6437256..c7a696df4 100644
--- a/engine/utils/config_yaml_utils.cc
+++ b/engine/utils/config_yaml_utils.cc
@@ -49,6 +49,7 @@ cpp::result<void, std::string> CortexConfigMgr::DumpYamlConfig(
     node["verifyHostSsl"] = config.verifyHostSsl;
     node["sslCertPath"] = config.sslCertPath;
     node["sslKeyPath"] = config.sslKeyPath;
+    node["supportedEngines"] = config.supportedEngines;
 
     out_file << node;
     out_file.close();
diff --git a/engine/utils/config_yaml_utils.h b/engine/utils/config_yaml_utils.h
index d36cc48e0..f9925ea86 100644
--- a/engine/utils/config_yaml_utils.h
+++ b/engine/utils/config_yaml_utils.h
@@ -3,6 +3,7 @@
 #include <mutex>
 #include <string>
 #include <vector>
+#include "utils/engine_constants.h"
 #include "utils/result.hpp"
 
 namespace config_yaml_utils {
@@ -18,6 +19,8 @@ constexpr const auto kDefaultCorsEnabled = true;
 const std::vector<std::string> kDefaultEnabledOrigins{
     "http://localhost:39281", "http://127.0.0.1:39281", "http://0.0.0.0:39281"};
 constexpr const auto kDefaultNoProxy = "example.com,::1,localhost,127.0.0.1";
+const std::vector<std::string> kDefaultSupportedEngines{
+    kLlamaEngine, kOnnxEngine, kTrtLlmEngine};
 
 struct CortexConfig {
   std::string logFolderPath;
@@ -57,6 +60,7 @@ struct CortexConfig {
   bool verifyHostSsl;
   std::string sslCertPath;
   std::string sslKeyPath;
+  std::vector<std::string> supportedEngines;
 };
 
 class CortexConfigMgr {
@@ -80,5 +84,4 @@ class CortexConfigMgr {
   CortexConfig FromYaml(const std::string& path,
                         const CortexConfig& default_cfg);
 };
-
 }  // namespace config_yaml_utils
diff --git a/engine/utils/file_manager_utils.cc b/engine/utils/file_manager_utils.cc
index ca3d0c07b..338abadac 100644
--- a/engine/utils/file_manager_utils.cc
+++ b/engine/utils/file_manager_utils.cc
@@ -187,6 +187,7 @@ config_yaml_utils::CortexConfig GetDefaultConfig() {
       .verifyHostSsl = true,
       .sslCertPath = "",
       .sslKeyPath = "",
+      .supportedEngines = config_yaml_utils::kDefaultSupportedEngines,
   };
 }