diff --git a/doc/api/embedding.md b/doc/api/embedding.md
index cda3481923add3..3828636bbe79c6 100644
--- a/doc/api/embedding.md
+++ b/doc/api/embedding.md
@@ -214,7 +214,6 @@ The C embedder API has the four major API function groups:
   set of functions. The embedding APIs provide access to functions that
   retrieve or create `napi_env` instances related to a runtime instance.
 
-
 ## API reference
 
 The C embedder API is split up by the four major groups described above.
@@ -234,7 +233,6 @@ added: REPLACEME
 This is an opaque pointer that represents a Node.js platform instance.
 Node.js allows only a single platform instance per process.
 
-
 ##### `node_embedding_platform_flags`
 
 <!-- YAML
@@ -291,7 +289,6 @@ Node.js platform initialization.
 - `node_embedding_platform_generate_predictable_snapshot` - Initialize the
   process for predictable snapshot generation.
 
-
 #### Callback types
 
 ##### `node_embedding_error_handler`
@@ -323,7 +320,6 @@ The callback parameters:
   `exit_code` is zero, then the callback is used to output non-error messages.
 - `[in] status`: Reported Node-API status.
 
-
 ##### `node_embedding_get_args_callback`
 
 <!-- YAML
@@ -347,7 +343,6 @@ The callback parameters:
 - `[in] argc`: Number of items in the `argv` array.
 - `[in] argv`: CLI arguments as an array of zero terminating strings.
 
-
 #### Functions
 
 ##### `node_embedding_on_error`
@@ -383,7 +378,6 @@ process with the `exit_code` when it is not zero.
 The zero `exit_code` indicates reported warnings or text messages. For example,
 it can be Node.js help text returned in response to the `--help` CLI argument.
 
-
 ##### `node_embedding_create_platform`
 
 <!-- YAML
@@ -410,7 +404,6 @@ other complex work that may fail. It only checks the argument.
 
 Node.js allows only a single platform instance per process.
 
-
 ##### `node_embedding_delete_platform`
 
 <!-- YAML
@@ -433,7 +426,6 @@ Returns `napi_ok` if there were no issues.
 If the platform was initialized before the deletion, then the method
 uninitializes the platform before deletion.
 
-
 ##### `node_embedding_platform_is_initialized`
 
 <!-- YAML
@@ -459,7 +451,6 @@ The platform instance settings can be changed until the platform is initialized.
 After the `node_embedding_platform_initialize` function call any attempt to
 change platform instance settings will fail.
 
-
 ##### `node_embedding_platform_set_flags`
 
 <!-- YAML
@@ -481,7 +472,6 @@ node_embedding_platform_set_flags(node_embedding_platform platform,
 
 Returns `napi_ok` if there were no issues.
 
-
 ##### `node_embedding_platform_set_args`
 
 <!-- YAML
@@ -505,7 +495,6 @@ node_embedding_platform_set_args(node_embedding_platform platform,
 
 Returns `napi_ok` if there were no issues.
 
-
 ##### `node_embedding_platform_initialize`
 
 <!-- YAML
@@ -538,7 +527,6 @@ changed anymore. The parsed arguments can be accessed by calling the
 `node_embedding_platform_get_args` and `node_embedding_platform_get_exec_args`
 functions.
 
-
 ##### `node_embedding_platform_get_args`
 
 <!-- YAML
@@ -563,7 +551,6 @@ node_embedding_platform_get_args(node_embedding_platform platform,
 
 Returns `napi_ok` if there were no issues.
 
-
 ##### `node_embedding_platform_get_exec_args`
 
 <!-- YAML
@@ -589,7 +576,6 @@ node_embedding_platform_get_exec_args(
 
 Returns `napi_ok` if there were no issues.
 
-
 ### Runtime instance APIs
 
 #### Data types
@@ -681,7 +667,6 @@ Node.js runtime initialization.
   during the runtime creation. It's used to call `node::Stop(env)` on a Worker
   thread that is waiting for the events.
 
-
 ##### `node_embedding_snapshot_flags`
 
 <!-- YAML
@@ -708,7 +693,6 @@ Node.js runtime snapshot creation.
   compiling functions included in the snapshot at the expense of a bigger
   snapshot size and potentially breaking portability of the snapshot.
 
-
 #### Callback types
 
 ##### `node_embedding_runtime_preload_callback`
@@ -737,7 +721,6 @@ The callback parameters:
 - `[in] process`: The Node.js `process` object.
 - `[in] require`: The internal `require` function.
 
-
 ##### `node_embedding_store_blob_callback`
 
 <!-- YAML
@@ -762,6 +745,35 @@ The callback parameters:
 - `[in] blob`: Start of the blob memory span.
 - `[in] size`: Size of the blob memory span.
 
+##### `node_embedding_initialize_module_callback`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+```c
+typedef napi_value(NAPI_CDECL* node_embedding_initialize_module_callback)(
+    void* cb_data,
+    napi_env env,
+    const char* module_name,
+    napi_value exports);
+```
+
+Function pointer type for initializing linked native module that can be defined
+in the embedder executable.
+
+The callback parameters:
+
+- `[in] cb_data`: The user data associated with this callback.
+- `[in] env`: Node API environment.
+- `[in] module_name`: Name of the module.
+- `[in] exports`: The `exports` module object.
+
+All module exports must be added as properties to the `exports` object.
+As an alternative a new object or another value can be created in the callback
+and returned.
 
 #### Functions
 
@@ -800,7 +812,6 @@ If it is planned to create more than one runtime instance or a non-default
 platform configuration is required, then it is recommended to create the
 Node.js platform instance explicitly.
 
-
 ##### `node_embedding_delete_runtime`
 
 <!-- YAML
@@ -827,7 +838,6 @@ As a part of the un-initialization it can store created snapshot blob if the
 `node_embedding_runtime_on_create_snapshot` set the callback to save the
 snapshot blob.
 
-
 ##### `node_embedding_runtime_is_initialized`
 
 <!-- YAML
@@ -853,7 +863,6 @@ The runtime settings can be changed until the runtime is initialized.
 After the `node_embedding_runtime_initialize` function is called any attempt to change
 runtime settings will fail.
 
-
 ##### `node_embedding_runtime_set_flags`
 
 <!-- YAML
@@ -875,7 +884,6 @@ node_embedding_runtime_set_flags(node_embedding_runtime runtime,
 
 Returns `napi_ok` if there were no issues.
 
-
 ##### `node_embedding_runtime_set_args`
 
 Sets the non-Node.js arguments for the Node.js runtime instance.
@@ -893,7 +901,6 @@ node_embedding_runtime_set_args(node_embedding_runtime runtime,
 
 Returns `napi_ok` if there were no issues.
 
-
 ##### `node_embedding_runtime_set_exec_args`
 
 Sets the Node.js arguments for the Node.js runtime instance.
@@ -911,7 +918,6 @@ node_embedding_runtime_set_exec_args(node_embedding_runtime runtime,
 
 Returns `napi_ok` if there were no issues.
 
-
 ##### `node_embedding_runtime_on_preload`
 
 <!-- YAML
@@ -939,7 +945,6 @@ node_embedding_runtime_on_preload(
 
 Returns `napi_ok` if there were no issues.
 
-
 ##### `node_embedding_runtime_use_snapshot`
 
 <!-- YAML
@@ -963,7 +968,6 @@ node_embedding_runtime_use_snapshot(node_embedding_runtime runtime,
 
 Returns `napi_ok` if there were no issues.
 
-
 ##### `node_embedding_runtime_on_create_snapshot`
 
 <!-- YAML
@@ -994,6 +998,38 @@ node_embedding_runtime_on_create_snapshot(
 
 Returns `napi_ok` if there were no issues.
 
+##### `node_embedding_runtime_add_module`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+Adds a linked module for the Node.js runtime instance.
+
+```c
+napi_status NAPI_CDECL
+node_embedding_runtime_add_module(
+    node_embedding_runtime runtime,
+    const char* module_name,
+    node_embedding_initialize_module_callback init_module_cb,
+    void* init_module_cb_data,
+    int32_t module_node_api_version);
+```
+
+- `[in] runtime`: The Node.js runtime instance.
+- `[in] module_name`: The name of the module.
+- `[in] init_module_cb`: Module initialization callback. It is called for the
+  main and worker threads. The caller must take care about the thread safety.
+- `[in] init_module_cb_data`: The user data for the init_module_cb.
+- `[in] module_node_api_version`: The Node API version used by the module.
+
+Returns `napi_ok` if there were no issues.
+
+The registered module can be accessed in JavaScript as
+`process._linkedBinding(module_name)` in the main JS and in the related
+worker threads.
 
 ##### `node_embedding_runtime_initialize`
 
@@ -1022,7 +1058,6 @@ with a V8 `Isolate` and V8 `Context`.
 After the initialization is completed the Node.js runtime settings cannot be
 changed anymore.
 
-
 ### Event loop APIs
 
 #### Data types
@@ -1052,7 +1087,6 @@ beahvior.
 - `node_embedding_event_loop_run_nowait` - Run the event loop once and do not
   wait if there are no items. It matches the `UV_RUN_NOWAIT` behavior.
 
-
 #### Callback types
 
 ##### `node_embedding_event_loop_predicate`
@@ -1079,7 +1113,6 @@ The callback parameters:
 
 Returns `true` if the runtime loop must continue to run.
 
-
 #### Functions
 
 ##### `node_embedding_runtime_run_event_loop`
@@ -1103,7 +1136,6 @@ Returns `napi_ok` if there were no issues.
 
 The function exits when there are no more tasks to process in the loop.
 
-
 ##### `node_embedding_runtime_run_event_loop_while`
 
 <!-- YAML
@@ -1129,7 +1161,7 @@ node_embedding_runtime_run_event_loop_while(
 - `[in] predicate`: The predicate to check before each runtime event loop
   task invocation.
 - `[in] predicate_data`: Optional. The predicate data that will be
-  passed to the `predicate` callback. It can be removed right after this 
+  passed to the `predicate` callback. It can be removed right after this
   function call.
 - `[in] run_mode`: Specifies behavior in case if the event loop does not have
   items to process. The `node_embedding_event_loop_run_once` will block the
@@ -1140,7 +1172,6 @@ node_embedding_runtime_run_event_loop_while(
 
 Returns `napi_ok` if there were no issues.
 
-
 ##### `node_embedding_runtime_await_promise`
 
 <!-- YAML
@@ -1169,7 +1200,6 @@ node_embedding_runtime_await_promise(node_embedding_runtime runtime,
 
 Returns `napi_ok` if there were no issues.
 
-
 ### JavaScript/Native interop APIs
 
 #### Functions
@@ -1197,7 +1227,6 @@ Returns `napi_ok` if there were no issues.
 
 By default it is using the Node-API version 8.
 
-
 ##### `node_embedding_runtime_get_node_api_env`
 
 <!-- YAML
@@ -1219,7 +1248,6 @@ node_embedding_runtime_get_node_api_env(node_runtime embedding_runtime,
 
 Returns `napi_ok` if there were no issues.
 
-
 ##### `node_embedding_runtime_open_scope`
 
 <!-- YAML
@@ -1247,7 +1275,6 @@ Then, it opens the V8 Handle scope and the V8 Context scope.
 It enables use of V8 API and the Node APIs which is a C API on top of
 the V8 API.
 
-
 ##### `node_runtime_close_scope`
 
 <!-- YAML
@@ -1274,7 +1301,6 @@ current thread. Each opened runtime scoped must be closed in the end.
 This function closes V8 Context scope, V8 Handle scope, V8 Isolate scope, and
 then makes the V8 Isolate leave the current thread.
 
-
 ## Examples
 
 The examples listed here are part of the Node.js
diff --git a/src/node_api.cc b/src/node_api.cc
index a019a1826c6ce7..6c4488e5310fd0 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -164,9 +164,11 @@ void ThrowNodeApiVersionError(node::Environment* node_env,
   node_env->ThrowError(error_message.c_str());
 }
 
-inline napi_env NewEnv(v8::Local<v8::Context> context,
-                       const std::string& module_filename,
-                       int32_t module_api_version) {
+}  // namespace
+
+napi_env NewEnv(v8::Local<v8::Context> context,
+                const std::string& module_filename,
+                int32_t module_api_version) {
   node_napi_env result;
 
   // Validate module_api_version.
@@ -196,6 +198,8 @@ inline napi_env NewEnv(v8::Local<v8::Context> context,
   return result;
 }
 
+namespace {
+
 class ThreadSafeFunction : public node::AsyncResource {
  public:
   ThreadSafeFunction(v8::Local<v8::Function> func,
diff --git a/src/node_embedding_api.cc b/src/node_embedding_api.cc
index 5cbe1027d43f52..de9ce216f43683 100644
--- a/src/node_embedding_api.cc
+++ b/src/node_embedding_api.cc
@@ -7,6 +7,7 @@
 #include "util-inl.h"
 
 #include <mutex>
+#include <string>
 
 // Use macros to handle errors since they can record the failing argument name
 // or expression and their location in the source code.
@@ -66,6 +67,10 @@ v8::Maybe<ExitCode> SpinEventLoopWithoutCleanup(
 }  // end of namespace node
 
 namespace v8impl {
+
+napi_env NewEnv(v8::Local<v8::Context> context,
+                const std::string& module_filename,
+                int32_t module_api_version);
 namespace {
 
 // A helper class to convert std::vector<std::string> to an array of C strings.
@@ -250,6 +255,12 @@ class EmbeddedRuntime {
       void* store_blob_cb_data,
       node_embedding_snapshot_flags snapshot_flags);
 
+  napi_status AddModule(
+      const char* module_name,
+      node_embedding_initialize_module_callback init_module_cb,
+      void* init_module_cb_data,
+      int32_t module_node_api_version);
+
   napi_status Initialize(const char* main_script);
 
   napi_status RunEventLoop();
@@ -282,6 +293,21 @@ class EmbeddedRuntime {
   static node::EnvironmentFlags::Flags GetEnvironmentFlags(
       node_embedding_runtime_flags flags);
 
+  void RegisterModules();
+
+  static void RegisterModule(v8::Local<v8::Object> exports,
+                             v8::Local<v8::Value> module,
+                             v8::Local<v8::Context> context,
+                             void* priv);
+
+ private:
+  struct ModuleInfo {
+    std::string module_name;
+    node_embedding_initialize_module_callback init_module_cb;
+    void* init_module_cb_data;
+    int32_t module_node_api_version;
+  };
+
  private:
   EmbeddedPlatform* platform_;
   bool is_initialized_{false};
@@ -301,6 +327,8 @@ class EmbeddedRuntime {
     bool exec_args : 1;
   } optional_bits_{};
 
+  std::unordered_map<std::string, ModuleInfo> modules_;
+
   std::unique_ptr<node::CommonEnvironmentSetup> env_setup_;
   std::optional<IsolateLocker> isolate_locker_;
 
@@ -667,6 +695,31 @@ napi_status EmbeddedRuntime::OnCreateSnapshotBlob(
   return napi_ok;
 }
 
+napi_status EmbeddedRuntime::AddModule(
+    const char* module_name,
+    node_embedding_initialize_module_callback init_module_cb,
+    void* init_module_cb_data,
+    int32_t module_node_api_version) {
+  ARG_NOT_NULL(module_name);
+  ARG_NOT_NULL(init_module_cb);
+  ASSERT(!is_initialized_);
+
+  auto insert_result = modules_.try_emplace(module_name,
+                                            module_name,
+                                            init_module_cb,
+                                            init_module_cb_data,
+                                            module_node_api_version);
+  if (!insert_result.second) {
+    return EmbeddedErrorHandling::HandleError(
+        EmbeddedErrorHandling::FormatString(
+            "Module with name '%s' is already added.", module_name),
+        1,
+        napi_invalid_arg);
+  }
+
+  return napi_ok;
+}
+
 // TODO: (vmoroz) avoid passing the main_script this way.
 napi_status EmbeddedRuntime::Initialize(const char* main_script) {
   ASSERT(!is_initialized_);
@@ -709,6 +762,8 @@ napi_status EmbeddedRuntime::Initialize(const char* main_script) {
 
   node::Environment* node_env = env_setup_->env();
 
+  RegisterModules();
+
   v8::MaybeLocal<v8::Value> ret =
       snapshot_
           ? node::LoadEnvironment(node_env, node::StartExecutionCallback{})
@@ -728,7 +783,7 @@ napi_status EmbeddedRuntime::RunEventLoop() {
   return napi_ok;
 }
 
-// TODO: (vmoroz) add support for is_thread_blocking.
+// TODO: (vmoroz) add support node_embedding_event_loop_run_once.
 napi_status EmbeddedRuntime::RunEventLoopWhile(
     node_embedding_event_loop_predicate predicate,
     void* predicate_data,
@@ -894,6 +949,52 @@ node::EnvironmentFlags::Flags EmbeddedRuntime::GetEnvironmentFlags(
   return static_cast<node::EnvironmentFlags::Flags>(result);
 }
 
+void EmbeddedRuntime::RegisterModules() {
+  for (const auto& [module_name, module_info] : modules_) {
+    node::node_module mod = {
+        -1,                                     // nm_version for Node-API
+        NM_F_LINKED,                            // nm_flags
+        nullptr,                                // nm_dso_handle
+        nullptr,                                // nm_filename
+        nullptr,                                // nm_register_func
+        RegisterModule,                         // nm_context_register_func
+        module_name.c_str(),                    // nm_modname
+        const_cast<ModuleInfo*>(&module_info),  // nm_priv
+        nullptr                                 // nm_link
+    };
+    node::AddLinkedBinding(env_setup_->env(), mod);
+  }
+}
+
+/*static*/ void EmbeddedRuntime::RegisterModule(v8::Local<v8::Object> exports,
+                                                v8::Local<v8::Value> module,
+                                                v8::Local<v8::Context> context,
+                                                void* priv) {
+  ModuleInfo* module_info = static_cast<ModuleInfo*>(priv);
+
+  // Create a new napi_env for this specific module.
+  napi_env env = v8impl::NewEnv(
+      context, module_info->module_name, module_info->module_node_api_version);
+
+  napi_value node_api_exports = nullptr;
+  env->CallIntoModule([&](napi_env env) {
+    node_api_exports =
+        module_info->init_module_cb(module_info->init_module_cb_data,
+                                    env,
+                                    module_info->module_name.c_str(),
+                                    v8impl::JsValueFromV8LocalValue(exports));
+  });
+
+  // If register function returned a non-null exports object different from
+  // the exports object we passed it, set that as the "exports" property of
+  // the module.
+  if (node_api_exports != nullptr &&
+      node_api_exports != v8impl::JsValueFromV8LocalValue(exports)) {
+    napi_value node_api_module = v8impl::JsValueFromV8LocalValue(module);
+    napi_set_named_property(env, node_api_module, "exports", node_api_exports);
+  }
+}
+
 }  // end of anonymous namespace
 }  // end of namespace v8impl
 
@@ -1002,6 +1103,18 @@ napi_status NAPI_CDECL node_embedding_runtime_on_create_snapshot(
       store_blob_cb, store_blob_cb_data, snapshot_flags);
 }
 
+NAPI_EXTERN napi_status NAPI_CDECL node_embedding_runtime_add_module(
+    node_embedding_runtime runtime,
+    const char* module_name,
+    node_embedding_initialize_module_callback init_module_cb,
+    void* init_module_cb_data,
+    int32_t module_node_api_version) {
+  return EMBEDDED_RUNTIME(runtime)->AddModule(module_name,
+                                              init_module_cb,
+                                              init_module_cb_data,
+                                              module_node_api_version);
+}
+
 napi_status NAPI_CDECL node_embedding_runtime_initialize(
     node_embedding_runtime runtime, const char* main_script) {
   return EMBEDDED_RUNTIME(runtime)->Initialize(main_script);
diff --git a/src/node_embedding_api.h b/src/node_embedding_api.h
index 418b8e53387c65..7e35fa62a5e298 100644
--- a/src/node_embedding_api.h
+++ b/src/node_embedding_api.h
@@ -153,6 +153,9 @@ typedef void(NAPI_CDECL* node_embedding_preload_callback)(void* cb_data,
 typedef void(NAPI_CDECL* node_embedding_store_blob_callback)(
     void* cb_data, const uint8_t* blob, size_t size);
 
+typedef napi_value(NAPI_CDECL* node_embedding_initialize_module_callback)(
+    void* cb_data, napi_env env, const char* module_name, napi_value exports);
+
 typedef bool(NAPI_CDECL* node_embedding_event_loop_predicate)(
     void* predicate_data, bool has_work);
 
@@ -253,6 +256,16 @@ NAPI_EXTERN napi_status NAPI_CDECL node_embedding_runtime_on_create_snapshot(
     void* store_blob_cb_data,
     node_embedding_snapshot_flags snapshot_flags);
 
+// Adds a new module to the Node.js runtime.
+// It is accessed as process._linkedBinding(module_name) in the main JS and in
+// the related worker threads.
+NAPI_EXTERN napi_status NAPI_CDECL node_embedding_runtime_add_module(
+    node_embedding_runtime runtime,
+    const char* module_name,
+    node_embedding_initialize_module_callback init_module_cb,
+    void* init_module_cb_data,
+    int32_t module_node_api_version);
+
 // Initializes the Node.js runtime.
 NAPI_EXTERN napi_status NAPI_CDECL node_embedding_runtime_initialize(
     node_embedding_runtime runtime, const char* main_script);
@@ -345,7 +358,6 @@ inline constexpr node_embedding_snapshot_flags operator|(
 // TODO: (vmoroz) Can we init plat again if it returns early?
 // TODO: (vmoroz) Add simpler threading model - without open/close scope.
 // TODO: (vmoroz) Simplify API use for simple default cases.
-// TODO: (vmoroz) Add a way to add embedded modules.
 // TODO: (vmoroz) Check how to pass the V8 thread pool size.
 
 // TODO: (vmoroz) Make the args story simpler or clear named.
diff --git a/test/embedding/embedtest_concurrent_node_api.cc b/test/embedding/embedtest_concurrent_node_api.cc
index f1394b625f1a27..d060b6d89c34af 100644
--- a/test/embedding/embedtest_concurrent_node_api.cc
+++ b/test/embedding/embedtest_concurrent_node_api.cc
@@ -3,10 +3,6 @@
 #include <mutex>
 #include <thread>
 
-static const char* main_script =
-    "globalThis.require = require('module').createRequire(process.execPath);\n"
-    "require('vm').runInThisContext(process.argv[1]);";
-
 // Tests that multiple runtimes can be run at the same time in their own
 // threads. The test creates 12 threads and 12 runtimes. Each runtime runs in it
 // own thread.
diff --git a/test/embedding/embedtest_main.cc b/test/embedding/embedtest_main.cc
index 388ff6f6d03abe..a585dc1619a1aa 100644
--- a/test/embedding/embedtest_main.cc
+++ b/test/embedding/embedtest_main.cc
@@ -5,6 +5,8 @@
 extern "C" int32_t test_main_cpp_api(int32_t argc, char* argv[]);
 extern "C" int32_t test_main_node_api(int32_t argc, char* argv[]);
 extern "C" int32_t test_main_modules_node_api(int32_t argc, char* argv[]);
+extern "C" int32_t test_main_linked_modules_node_api(int32_t argc,
+                                                     char* argv[]);
 extern "C" int32_t test_main_concurrent_node_api(int32_t argc, char* argv[]);
 extern "C" int32_t test_main_multi_env_node_api(int32_t argc, char* argv[]);
 extern "C" int32_t test_main_multi_thread_node_api(int32_t argc, char* argv[]);
@@ -33,6 +35,8 @@ NODE_MAIN(int32_t argc, node::argv_type raw_argv[]) {
       return CallWithoutArg1(test_main_node_api, argc, argv);
     } else if (strcmp(arg1, "modules-node-api") == 0) {
       return CallWithoutArg1(test_main_modules_node_api, argc, argv);
+    } else if (strcmp(arg1, "linked-modules-node-api") == 0) {
+      return CallWithoutArg1(test_main_linked_modules_node_api, argc, argv);
     } else if (strcmp(arg1, "concurrent-node-api") == 0) {
       return CallWithoutArg1(test_main_concurrent_node_api, argc, argv);
     } else if (strcmp(arg1, "multi-env-node-api") == 0) {
diff --git a/test/embedding/embedtest_modules_node_api.cc b/test/embedding/embedtest_modules_node_api.cc
index 96700bd14ed4c4..fa7ead2e4f96ca 100644
--- a/test/embedding/embedtest_modules_node_api.cc
+++ b/test/embedding/embedtest_modules_node_api.cc
@@ -1,8 +1,128 @@
 #include "embedtest_node_api.h"
 
+#include <atomic>
 #include <cstdio>
 #include <cstring>
 
+static napi_value NAPI_CDECL InitGreeterModule(void* cb_data,
+                                               napi_env env,
+                                               const char* module_name,
+                                               napi_value exports) {
+  std::atomic<int32_t>* counter_ptr =
+      static_cast<std::atomic<int32_t>*>(cb_data);
+  counter_ptr->fetch_add(1);
+
+  napi_value greet_func{};
+  napi_create_function(
+      env,
+      "greet",
+      NAPI_AUTO_LENGTH,
+      [](napi_env env, napi_callback_info info) -> napi_value {
+        std::string greeting = "Hello, ";
+        napi_value arg;
+        size_t arg_count = 1;
+        napi_get_cb_info(env, info, &arg_count, &arg, nullptr, nullptr);
+        AddUtf8String(greeting, env, arg);
+        napi_value result;
+        napi_create_string_utf8(
+            env, greeting.c_str(), greeting.size(), &result);
+        return result;
+      },
+      nullptr,
+      &greet_func);
+  napi_set_named_property(env, exports, "greet", greet_func);
+  return exports;
+}
+
+static napi_value NAPI_CDECL InitReplicatorModule(void* cb_data,
+                                                  napi_env env,
+                                                  const char* module_name,
+                                                  napi_value exports) {
+  std::atomic<int32_t>* counter_ptr =
+      static_cast<std::atomic<int32_t>*>(cb_data);
+  counter_ptr->fetch_add(1);
+
+  napi_value greet_func{};
+  napi_create_function(
+      env,
+      "replicate",
+      NAPI_AUTO_LENGTH,
+      [](napi_env env, napi_callback_info info) -> napi_value {
+        std::string str;
+        napi_value arg;
+        size_t arg_count = 1;
+        napi_get_cb_info(env, info, &arg_count, &arg, nullptr, nullptr);
+        AddUtf8String(str, env, arg);
+        str += " " + str;
+        napi_value result;
+        napi_create_string_utf8(env, str.c_str(), str.size(), &result);
+        return result;
+      },
+      nullptr,
+      &greet_func);
+  napi_set_named_property(env, exports, "replicate", greet_func);
+  return exports;
+}
+
+extern "C" int32_t test_main_linked_modules_node_api(int32_t argc,
+                                                     char* argv[]) {
+  CHECK_TRUE(argc == 4);
+  int32_t expectedGreeterModuleInitCallCount = atoi(argv[2]);
+  int32_t expectedReplicatorModuleInitCallCount = atoi(argv[2]);
+
+  std::atomic<int32_t> greeterModuleInitCallCount{0};
+  std::atomic<int32_t> replicatorModuleInitCallCount{0};
+
+  CHECK(node_embedding_on_error(HandleTestError, argv[0]));
+
+  node_embedding_platform platform;
+  CHECK(node_embedding_create_platform(NODE_EMBEDDING_VERSION, &platform));
+  CHECK(node_embedding_platform_set_args(platform, argc, argv));
+  bool early_return = false;
+  CHECK(node_embedding_platform_initialize(platform, &early_return));
+  if (early_return) {
+    return 0;
+  }
+
+  node_embedding_runtime runtime;
+  CHECK(node_embedding_create_runtime(platform, &runtime));
+  CHECK(node_embedding_runtime_set_node_api_version(runtime, NAPI_VERSION));
+
+  CHECK(node_embedding_runtime_on_preload(
+      runtime,
+      [](void* /*cb_data*/,
+         napi_env env,
+         napi_value process,
+         napi_value /*require*/
+      ) {
+        napi_value global;
+        napi_get_global(env, &global);
+        napi_set_named_property(env, global, "process", process);
+      },
+      nullptr));
+
+  CHECK(node_embedding_runtime_add_module(runtime,
+                                          "greeter_module",
+                                          &InitGreeterModule,
+                                          &greeterModuleInitCallCount,
+                                          NAPI_VERSION));
+  CHECK(node_embedding_runtime_add_module(runtime,
+                                          "replicator_module",
+                                          &InitReplicatorModule,
+                                          &replicatorModuleInitCallCount,
+                                          NAPI_VERSION));
+
+  CHECK(node_embedding_runtime_initialize(runtime, main_script));
+
+  CHECK(node_embedding_delete_runtime(runtime));
+  CHECK(node_embedding_delete_platform(platform));
+
+  CHECK_TRUE(greeterModuleInitCallCount == expectedGreeterModuleInitCallCount);
+  CHECK_TRUE(replicatorModuleInitCallCount ==
+             expectedReplicatorModuleInitCallCount);
+  return 0;
+}
+
 extern "C" int32_t test_main_modules_node_api(int32_t argc, char* argv[]) {
   if (argc < 3) {
     fprintf(stderr, "node_api_modules <cjs.cjs> <es6.mjs>\n");
diff --git a/test/embedding/embedtest_node_api.cc b/test/embedding/embedtest_node_api.cc
index 01e7cdadeddc2f..462984332dac16 100644
--- a/test/embedding/embedtest_node_api.cc
+++ b/test/embedding/embedtest_node_api.cc
@@ -4,7 +4,7 @@
 #include <stdio.h>
 #include <string.h>
 
-static const char* main_script =
+const char* main_script =
     "globalThis.require = require('module').createRequire(process.execPath);\n"
     "globalThis.embedVars = { nön_ascıı: '🏳️‍🌈' };\n"
     "require('vm').runInThisContext(process.argv[1]);";
@@ -31,6 +31,18 @@ extern "C" int32_t test_main_node_api(int32_t argc, char* argv[]) {
   return 0;
 }
 
+napi_status AddUtf8String(std::string& str, napi_env env, napi_value value) {
+  size_t str_size = 0;
+  napi_status status = napi_get_value_string_utf8(env, value, nullptr, 0, &str_size);
+  if (status != napi_ok) {
+    return status;
+  }
+  size_t offset = str.size();
+  str.resize(offset + str_size);
+  status = napi_get_value_string_utf8(env, value, &str[0] + offset, str_size + 1, &str_size);
+  return status;
+}
+
 int32_t callMe(napi_env env) {
   napi_value global;
   napi_value cb;
diff --git a/test/embedding/embedtest_node_api.h b/test/embedding/embedtest_node_api.h
index acf9a87f1c23a0..f449161d3b352c 100644
--- a/test/embedding/embedtest_node_api.h
+++ b/test/embedding/embedtest_node_api.h
@@ -33,6 +33,10 @@ extern "C" inline napi_status NAPI_CDECL HandleTestError(void* handler_data,
 
 #endif
 
+extern const char* main_script;
+
+napi_status AddUtf8String(std::string& str, napi_env env, napi_value value);
+
 #define CHECK(expr)                                                            \
   do {                                                                         \
     if ((expr) != napi_ok) {                                                   \
diff --git a/test/embedding/embedtest_preload_node_api.cc b/test/embedding/embedtest_preload_node_api.cc
index c1871685fff879..abc407e146dca3 100644
--- a/test/embedding/embedtest_preload_node_api.cc
+++ b/test/embedding/embedtest_preload_node_api.cc
@@ -3,10 +3,6 @@
 #include <mutex>
 #include <thread>
 
-static const char* main_script =
-    "globalThis.require = require('module').createRequire(process.execPath);\n"
-    "require('vm').runInThisContext(process.argv[1]);";
-
 // Tests that the same preload callback is called from the main thread and from
 // the worker thread.
 extern "C" int32_t test_main_preload_node_api(int32_t argc, char* argv[]) {
diff --git a/test/embedding/embedtest_snapshot_node_api.cc b/test/embedding/embedtest_snapshot_node_api.cc
index 0bf7d99d65788a..c48a647b467c87 100644
--- a/test/embedding/embedtest_snapshot_node_api.cc
+++ b/test/embedding/embedtest_snapshot_node_api.cc
@@ -167,13 +167,7 @@ int32_t RunNodeInstance(node_embedding_platform platform) {
         "globalThis.require = require;"
         "require('vm').runInThisContext(process.argv[2]);"));
   } else {
-    CHECK(node_embedding_runtime_initialize(
-        runtime,
-        "const publicRequire = require('module').createRequire(process.cwd() + "
-        "'/');"
-        "globalThis.require = publicRequire;"
-        "globalThis.embedVars = { nön_ascıı: '🏳️‍🌈' };"
-        "require('vm').runInThisContext(process.argv[1]);"));
+    CHECK(node_embedding_runtime_initialize(runtime, main_script));
   }
 
   CHECK(node_embedding_delete_runtime(runtime));
diff --git a/test/embedding/test-embedding.js b/test/embedding/test-embedding.js
index fc325c530bb192..6504004f7e7aa0 100644
--- a/test/embedding/test-embedding.js
+++ b/test/embedding/test-embedding.js
@@ -120,7 +120,9 @@ function runCommonApiTests(apiType) {
       status: 9,
       signal: null,
       trim: true,
-      stderr: `${binary}: NODE_REPL_EXTERNAL_MODULE can't be used with kDisableNodeOptionsEnv`,
+      stderr:
+        `${binary}: NODE_REPL_EXTERNAL_MODULE can't be used with` +
+        ' kDisableNodeOptionsEnv',
     }
   );
 }
@@ -258,8 +260,10 @@ runSnapshotTests('snapshot-node-api');
     spawnSyncAndAssert,
     [
       'node-api',
-      'function waitPromise(text)' +
-        '{ return new Promise((res) => setTimeout(() => res(text + " with cheese"), 1)); }',
+      'function waitPromise(text) { ' +
+        'return new Promise((res) => ' +
+        '  setTimeout(() => res(text + " with cheese"), 1)); ' +
+        '}',
     ],
     { stdout: 'waited with cheese' }
   );
@@ -269,8 +273,10 @@ runSnapshotTests('snapshot-node-api');
     spawnSyncAndAssert,
     [
       'node-api',
-      'function waitPromise(text)' +
-        '{ return new Promise((res, rej) => setTimeout(() => rej(text + " without cheese"), 1)); }',
+      'function waitPromise(text) { ' +
+        'return new Promise((res, rej) => ' +
+        '  setTimeout(() => rej(text + " without cheese"), 1)); ' +
+        '}',
     ],
     { stdout: 'waited without cheese' }
   );
@@ -290,7 +296,11 @@ runSnapshotTests('snapshot-node-api');
     spawnSyncAndAssert,
     [
       'multi-env-node-api',
-      'myCount = 0; function incMyCount() { ++myCount; if (myCount < 5) { setTimeout(incMyCount, 1); } }',
+      'myCount = 0; ' +
+        'function incMyCount() { ' +
+        '  ++myCount; ' +
+        '  if (myCount < 5) setTimeout(incMyCount, 1); ' +
+        '}',
     ],
     {
       trim: true,
@@ -303,7 +313,11 @@ runSnapshotTests('snapshot-node-api');
     spawnSyncAndAssert,
     [
       'multi-thread-node-api',
-      'myCount = 0; function incMyCount() { ++myCount; if (myCount < 5) { setTimeout(incMyCount, 1); } }',
+      'myCount = 0; ' +
+        'function incMyCount() { ' +
+        '  ++myCount; ' +
+        '  if (myCount < 5) setTimeout(incMyCount, 1); ' +
+        '}',
     ],
     {
       trim: true,
@@ -323,6 +337,24 @@ runSnapshotTests('snapshot-node-api');
       stdout: `preloadValue=42; worker preloadValue=42`,
     }
   );
+
+  const linkedModulesScriptPath = path.join(__dirname, 'use-linked-modules.js');
+
+  runTest(
+    'linked-modules-node-api: run with two linked modules',
+    spawnSyncAndAssert,
+    [
+      'linked-modules-node-api',
+      `eval(${getReadFileCodeForPath(linkedModulesScriptPath)})`,
+      2, // expected number of greeter module calls
+      2, // expected number of replicator module calls
+    ],
+    {
+      cwd: __dirname,
+      trim: true,
+      stdout: 'main=Hello, World World; worker=Hello, Node Node',
+    }
+  );
 }
 
 /*
diff --git a/test/embedding/use-linked-modules.js b/test/embedding/use-linked-modules.js
new file mode 100644
index 00000000000000..0ffc2330bbef15
--- /dev/null
+++ b/test/embedding/use-linked-modules.js
@@ -0,0 +1,28 @@
+// Check that the linked modules defined in the executable can be used in
+// the main thread and worker thread.
+
+// Use the greeter and replicator modules in the main thread.
+const greeterModule = process._linkedBinding('greeter_module');
+const replicatorModule = process._linkedBinding('replicator_module');
+
+const names = replicatorModule.replicate('World');
+const greeting = greeterModule.greet(names);
+
+// Use the greeter and replicator modules in the worker thread.
+const { Worker } = require('worker_threads');
+const worker = new Worker(
+  'const greeterModule = process._linkedBinding("greeter_module");\n' +
+    'const replicatorModule = process._linkedBinding("replicator_module");\n' +
+    'const names = replicatorModule.replicate("Node");\n' +
+    'const greeting = greeterModule.greet(names);\n' +
+    'require("worker_threads").parentPort.postMessage({greeting});',
+  { eval: true }
+);
+
+const messages = [];
+worker.on('message', (message) => messages.push(message));
+
+// Print the greetings from the main thread and worker thread.
+process.on('beforeExit', () => {
+  console.log(`main=${greeting}; worker=${messages[0].greeting}`);
+});