diff --git a/lib/internal/bootstrap/cache.js b/lib/internal/bootstrap/cache.js
index 41159d650bc375..ff6c4422c1148c 100644
--- a/lib/internal/bootstrap/cache.js
+++ b/lib/internal/bootstrap/cache.js
@@ -8,20 +8,13 @@
 const {
   NativeModule
 } = require('internal/bootstrap/loaders');
+const {
+  source,
+  compileCodeCache
+} = internalBinding('native_module');
 const { hasTracing } = process.binding('config');
 
-function getCodeCache(id) {
-  const cached = NativeModule.getCached(id);
-  if (cached && (cached.loaded || cached.loading)) {
-    return cached.script.createCachedData();
-  }
-
-  // The script has not been compiled and run
-  NativeModule.require(id);
-  return getCodeCache(id);
-}
-
-const depsModule = Object.keys(NativeModule._source).filter(
+const depsModule = Object.keys(source).filter(
   (key) => NativeModule.isDepsModule(key) || key.startsWith('internal/deps')
 );
 
@@ -75,17 +68,10 @@ if (!process.versions.openssl) {
 }
 
 module.exports = {
-  cachableBuiltins: Object.keys(NativeModule._source).filter(
+  cachableBuiltins: Object.keys(source).filter(
     (key) => !cannotUseCache.includes(key)
   ),
-  builtinSource: Object.assign({}, NativeModule._source),
-  getCodeCache,
-  getSource: NativeModule.getSource,
-  codeCache: internalBinding('code_cache'),
-  compiledWithoutCache: NativeModule.compiledWithoutCache,
-  compiledWithCache: NativeModule.compiledWithCache,
-  nativeModuleWrap(script) {
-    return NativeModule.wrap(script);
-  },
+  getSource(id) { return source[id]; },
+  getCodeCache: compileCodeCache,
   cannotUseCache
 };
diff --git a/lib/internal/bootstrap/loaders.js b/lib/internal/bootstrap/loaders.js
index 1879c0154c3179..78e1180dde2af2 100644
--- a/lib/internal/bootstrap/loaders.js
+++ b/lib/internal/bootstrap/loaders.js
@@ -149,7 +149,6 @@
 
   // Create this WeakMap in js-land because V8 has no C++ API for WeakMap
   internalBinding('module_wrap').callbackMap = new WeakMap();
-  const { ContextifyScript } = internalBinding('contextify');
 
   // Set up NativeModule
   function NativeModule(id) {
@@ -160,7 +159,6 @@
     this.exportKeys = undefined;
     this.loaded = false;
     this.loading = false;
-    this.script = null;  // The ContextifyScript of the module
   }
 
   NativeModule._source = getInternalBinding('natives');
@@ -168,12 +166,6 @@
 
   const config = getBinding('config');
 
-  const codeCache = getInternalBinding('code_cache');
-  const codeCacheHash = getInternalBinding('code_cache_hash');
-  const sourceHash = getInternalBinding('natives_hash');
-  const compiledWithoutCache = NativeModule.compiledWithoutCache = [];
-  const compiledWithCache = NativeModule.compiledWithCache = [];
-
   // Think of this as module.exports in this file even though it is not
   // written in CommonJS style.
   const loaderExports = { internalBinding, NativeModule };
@@ -332,67 +324,18 @@
     this.exports = new Proxy(this.exports, handler);
   };
 
+  const { compileFunction } = getInternalBinding('native_module');
   NativeModule.prototype.compile = function() {
     const id = this.id;
-    let source = NativeModule.getSource(id);
-    source = NativeModule.wrap(source);
 
     this.loading = true;
 
     try {
-      // Currently V8 only checks that the length of the source code is the
-      // same as the code used to generate the hash, so we add an additional
-      // check here:
-      // 1. During compile time, when generating node_javascript.cc and
-      //    node_code_cache.cc, we compute and include the hash of the
-      //   (unwrapped) JavaScript source in both.
-      // 2. At runtime, we check that the hash of the code being compiled
-      //   and the hash of the code used to generate the cache
-      //   (inside the wrapper) is the same.
-      // This is based on the assumptions:
-      // 1. `internalBinding('code_cache_hash')` must be in sync with
-      //    `internalBinding('code_cache')` (same C++ file)
-      // 2. `internalBinding('natives_hash')` must be in sync with
-      //    `internalBinding('natives')` (same C++ file)
-      // 3. If `internalBinding('natives_hash')` is in sync with
-      //    `internalBinding('natives_hash')`, then the (unwrapped)
-      //    code used to generate `internalBinding('code_cache')`
-      //    should be in sync with the (unwrapped) code in
-      //    `internalBinding('natives')`
-      // There will be, however, false positives if the wrapper used
-      // to generate the cache is different from the one used at run time,
-      // and the length of the wrapper somehow stays the same.
-      // But that should be rare and can be eased once we make the
-      // two bootstrappers cached and checked as well.
-      const cache = codeCacheHash[id] &&
-        (codeCacheHash[id] === sourceHash[id]) ? codeCache[id] : undefined;
-
-      // (code, filename, lineOffset, columnOffset
-      // cachedData, produceCachedData, parsingContext)
-      const script = new ContextifyScript(
-        source, this.filename, 0, 0,
-        cache, false, undefined
-      );
-
-      // This will be used to create code cache in tools/generate_code_cache.js
-      this.script = script;
-
-      // One of these conditions may be false when any of the inputs
-      // of the `node_js2c` target in node.gyp is modified.
-      // FIXME(joyeecheung): Figure out how to resolve the dependency issue.
-      // When the code cache was introduced we were at a point where refactoring
-      // node.gyp may not be worth the effort.
-      if (!cache || script.cachedDataRejected) {
-        compiledWithoutCache.push(this.id);
-      } else {
-        compiledWithCache.push(this.id);
-      }
-
-      // Arguments: timeout, displayErrors, breakOnSigint
-      const fn = script.runInThisContext(-1, true, false);
       const requireFn = this.id.startsWith('internal/deps/') ?
         NativeModule.requireForDeps :
         NativeModule.require;
+
+      const fn = compileFunction(id);
       fn(this.exports, requireFn, this, process, internalBinding);
 
       if (config.experimentalModules && !NativeModule.isInternal(this.id)) {
diff --git a/node.gyp b/node.gyp
index 83bd412dea6c9d..5b68281de45790 100644
--- a/node.gyp
+++ b/node.gyp
@@ -416,6 +416,8 @@
         'src/node_javascript.h',
         'src/node_messaging.h',
         'src/node_mutex.h',
+        'src/node_native_module.h',
+        'src/node_native_module.cc',
         'src/node_options.h',
         'src/node_options-inl.h',
         'src/node_perf.h',
diff --git a/src/env.h b/src/env.h
index 01f686833eab24..3ed76ac49d4b02 100644
--- a/src/env.h
+++ b/src/env.h
@@ -120,248 +120,258 @@ constexpr size_t kFsStatsBufferLength = kFsStatsFieldsNumber * 2;
 
 // Strings are per-isolate primitives but Environment proxies them
 // for the sake of convenience.  Strings should be ASCII-only.
-#define PER_ISOLATE_STRING_PROPERTIES(V)                                      \
-  V(address_string, "address")                                                \
-  V(aliases_string, "aliases")                                                \
-  V(args_string, "args")                                                      \
-  V(async_ids_stack_string, "async_ids_stack")                                \
-  V(buffer_string, "buffer")                                                  \
-  V(bytes_parsed_string, "bytesParsed")                                       \
-  V(bytes_read_string, "bytesRead")                                           \
-  V(bytes_written_string, "bytesWritten")                                     \
-  V(cached_data_string, "cachedData")                                         \
-  V(cached_data_produced_string, "cachedDataProduced")                        \
-  V(cached_data_rejected_string, "cachedDataRejected")                        \
-  V(change_string, "change")                                                  \
-  V(channel_string, "channel")                                                \
-  V(chunks_sent_since_last_write_string, "chunksSentSinceLastWrite")          \
-  V(constants_string, "constants")                                            \
-  V(oncertcb_string, "oncertcb")                                              \
-  V(code_string, "code")                                                      \
-  V(cwd_string, "cwd")                                                        \
-  V(dest_string, "dest")                                                      \
-  V(destroyed_string, "destroyed")                                            \
-  V(detached_string, "detached")                                              \
-  V(dns_a_string, "A")                                                        \
-  V(dns_aaaa_string, "AAAA")                                                  \
-  V(dns_cname_string, "CNAME")                                                \
-  V(dns_mx_string, "MX")                                                      \
-  V(dns_naptr_string, "NAPTR")                                                \
-  V(dns_ns_string, "NS")                                                      \
-  V(dns_ptr_string, "PTR")                                                    \
-  V(dns_soa_string, "SOA")                                                    \
-  V(dns_srv_string, "SRV")                                                    \
-  V(dns_txt_string, "TXT")                                                    \
-  V(duration_string, "duration")                                              \
-  V(emit_warning_string, "emitWarning")                                       \
-  V(exchange_string, "exchange")                                              \
-  V(encoding_string, "encoding")                                              \
-  V(entries_string, "entries")                                                \
-  V(entry_type_string, "entryType")                                           \
-  V(env_pairs_string, "envPairs")                                             \
-  V(env_var_settings_string, "envVarSettings")                                \
-  V(errno_string, "errno")                                                    \
-  V(error_string, "error")                                                    \
-  V(exit_code_string, "exitCode")                                             \
-  V(expire_string, "expire")                                                  \
-  V(exponent_string, "exponent")                                              \
-  V(exports_string, "exports")                                                \
-  V(ext_key_usage_string, "ext_key_usage")                                    \
-  V(external_stream_string, "_externalStream")                                \
-  V(family_string, "family")                                                  \
-  V(fatal_exception_string, "_fatalException")                                \
-  V(fd_string, "fd")                                                          \
-  V(file_string, "file")                                                      \
-  V(fingerprint_string, "fingerprint")                                        \
-  V(fingerprint256_string, "fingerprint256")                                  \
-  V(flags_string, "flags")                                                    \
-  V(fragment_string, "fragment")                                              \
-  V(get_data_clone_error_string, "_getDataCloneError")                        \
-  V(get_shared_array_buffer_id_string, "_getSharedArrayBufferId")             \
-  V(gid_string, "gid")                                                        \
-  V(handle_string, "handle")                                                  \
-  V(help_text_string, "helpText")                                             \
-  V(homedir_string, "homedir")                                                \
-  V(host_string, "host")                                                      \
-  V(hostmaster_string, "hostmaster")                                          \
-  V(ignore_string, "ignore")                                                  \
-  V(infoaccess_string, "infoAccess")                                          \
-  V(inherit_string, "inherit")                                                \
-  V(input_string, "input")                                                    \
-  V(internal_string, "internal")                                              \
-  V(ipv4_string, "IPv4")                                                      \
-  V(ipv6_string, "IPv6")                                                      \
-  V(isclosing_string, "isClosing")                                            \
-  V(issuer_string, "issuer")                                                  \
-  V(issuercert_string, "issuerCertificate")                                   \
-  V(kill_signal_string, "killSignal")                                         \
-  V(kind_string, "kind")                                                      \
-  V(mac_string, "mac")                                                        \
-  V(main_string, "main")                                                      \
-  V(max_buffer_string, "maxBuffer")                                           \
-  V(message_string, "message")                                                \
-  V(message_port_string, "messagePort")                                       \
-  V(message_port_constructor_string, "MessagePort")                           \
-  V(minttl_string, "minttl")                                                  \
-  V(modulus_string, "modulus")                                                \
-  V(name_string, "name")                                                      \
-  V(netmask_string, "netmask")                                                \
-  V(nsname_string, "nsname")                                                  \
-  V(ocsp_request_string, "OCSPRequest")                                       \
-  V(onaltsvc_string, "onaltsvc")                                              \
-  V(onchange_string, "onchange")                                              \
-  V(onclienthello_string, "onclienthello")                                    \
-  V(oncomplete_string, "oncomplete")                                          \
-  V(onconnection_string, "onconnection")                                      \
-  V(ondone_string, "ondone")                                                  \
-  V(onerror_string, "onerror")                                                \
-  V(onexit_string, "onexit")                                                  \
-  V(onframeerror_string, "onframeerror")                                      \
-  V(ongetpadding_string, "ongetpadding")                                      \
-  V(onhandshakedone_string, "onhandshakedone")                                \
-  V(onhandshakestart_string, "onhandshakestart")                              \
-  V(onheaders_string, "onheaders")                                            \
-  V(onmessage_string, "onmessage")                                            \
-  V(onnewsession_string, "onnewsession")                                      \
-  V(onocspresponse_string, "onocspresponse")                                  \
-  V(ongoawaydata_string, "ongoawaydata")                                      \
-  V(onorigin_string, "onorigin")                                              \
-  V(onpriority_string, "onpriority")                                          \
-  V(onread_string, "onread")                                                  \
-  V(onreadstart_string, "onreadstart")                                        \
-  V(onreadstop_string, "onreadstop")                                          \
-  V(onping_string, "onping")                                                  \
-  V(onsettings_string, "onsettings")                                          \
-  V(onshutdown_string, "onshutdown")                                          \
-  V(onsignal_string, "onsignal")                                              \
-  V(onstreamclose_string, "onstreamclose")                                    \
-  V(ontrailers_string, "ontrailers")                                          \
-  V(onunpipe_string, "onunpipe")                                              \
-  V(onwrite_string, "onwrite")                                                \
-  V(openssl_error_stack, "opensslErrorStack")                                 \
-  V(options_string, "options")                                                \
-  V(output_string, "output")                                                  \
-  V(order_string, "order")                                                    \
-  V(parse_error_string, "Parse Error")                                        \
-  V(password_string, "password")                                              \
-  V(path_string, "path")                                                      \
-  V(pending_handle_string, "pendingHandle")                                   \
-  V(pid_string, "pid")                                                        \
-  V(pipe_string, "pipe")                                                      \
-  V(pipe_target_string, "pipeTarget")                                         \
-  V(pipe_source_string, "pipeSource")                                         \
-  V(port_string, "port")                                                      \
-  V(port1_string, "port1")                                                    \
-  V(port2_string, "port2")                                                    \
-  V(preference_string, "preference")                                          \
-  V(priority_string, "priority")                                              \
-  V(promise_string, "promise")                                                \
-  V(pubkey_string, "pubkey")                                                  \
-  V(query_string, "query")                                                    \
-  V(raw_string, "raw")                                                        \
-  V(read_host_object_string, "_readHostObject")                               \
-  V(readable_string, "readable")                                              \
-  V(reason_string, "reason")                                                  \
-  V(refresh_string, "refresh")                                                \
-  V(regexp_string, "regexp")                                                  \
-  V(rename_string, "rename")                                                  \
-  V(replacement_string, "replacement")                                        \
-  V(retry_string, "retry")                                                    \
-  V(scheme_string, "scheme")                                                  \
-  V(serial_string, "serial")                                                  \
-  V(scopeid_string, "scopeid")                                                \
-  V(serial_number_string, "serialNumber")                                     \
-  V(service_string, "service")                                                \
-  V(servername_string, "servername")                                          \
-  V(session_id_string, "sessionId")                                           \
-  V(shell_string, "shell")                                                    \
-  V(signal_string, "signal")                                                  \
-  V(sink_string, "sink")                                                      \
-  V(size_string, "size")                                                      \
-  V(sni_context_err_string, "Invalid SNI context")                            \
-  V(sni_context_string, "sni_context")                                        \
-  V(source_string, "source")                                                  \
-  V(stack_string, "stack")                                                    \
-  V(start_time_string, "startTime")                                           \
-  V(status_string, "status")                                                  \
-  V(stdio_string, "stdio")                                                    \
-  V(subject_string, "subject")                                                \
-  V(subjectaltname_string, "subjectaltname")                                  \
-  V(syscall_string, "syscall")                                                \
-  V(thread_id_string, "threadId")                                             \
-  V(ticketkeycallback_string, "onticketkeycallback")                          \
-  V(timeout_string, "timeout")                                                \
-  V(tls_ticket_string, "tlsTicket")                                           \
-  V(ttl_string, "ttl")                                                        \
-  V(type_string, "type")                                                      \
-  V(uid_string, "uid")                                                        \
-  V(unknown_string, "<unknown>")                                              \
-  V(url_string, "url")                                                        \
-  V(username_string, "username")                                              \
-  V(valid_from_string, "valid_from")                                          \
-  V(valid_to_string, "valid_to")                                              \
-  V(value_string, "value")                                                    \
-  V(verify_error_string, "verifyError")                                       \
-  V(version_string, "version")                                                \
-  V(weight_string, "weight")                                                  \
-  V(windows_hide_string, "windowsHide")                                       \
-  V(windows_verbatim_arguments_string, "windowsVerbatimArguments")            \
-  V(wrap_string, "wrap")                                                      \
-  V(writable_string, "writable")                                              \
-  V(write_host_object_string, "_writeHostObject")                             \
-  V(write_queue_size_string, "writeQueueSize")                                \
-  V(x_forwarded_string, "x-forwarded-for")                                    \
+#define PER_ISOLATE_STRING_PROPERTIES(V)                                       \
+  V(address_string, "address")                                                 \
+  V(aliases_string, "aliases")                                                 \
+  V(args_string, "args")                                                       \
+  V(async_ids_stack_string, "async_ids_stack")                                 \
+  V(buffer_string, "buffer")                                                   \
+  V(bytes_parsed_string, "bytesParsed")                                        \
+  V(bytes_read_string, "bytesRead")                                            \
+  V(bytes_written_string, "bytesWritten")                                      \
+  V(cached_data_string, "cachedData")                                          \
+  V(cached_data_produced_string, "cachedDataProduced")                         \
+  V(cached_data_rejected_string, "cachedDataRejected")                         \
+  V(change_string, "change")                                                   \
+  V(channel_string, "channel")                                                 \
+  V(chunks_sent_since_last_write_string, "chunksSentSinceLastWrite")           \
+  V(constants_string, "constants")                                             \
+  V(oncertcb_string, "oncertcb")                                               \
+  V(code_string, "code")                                                       \
+  V(cwd_string, "cwd")                                                         \
+  V(dest_string, "dest")                                                       \
+  V(destroyed_string, "destroyed")                                             \
+  V(detached_string, "detached")                                               \
+  V(dns_a_string, "A")                                                         \
+  V(dns_aaaa_string, "AAAA")                                                   \
+  V(dns_cname_string, "CNAME")                                                 \
+  V(dns_mx_string, "MX")                                                       \
+  V(dns_naptr_string, "NAPTR")                                                 \
+  V(dns_ns_string, "NS")                                                       \
+  V(dns_ptr_string, "PTR")                                                     \
+  V(dns_soa_string, "SOA")                                                     \
+  V(dns_srv_string, "SRV")                                                     \
+  V(dns_txt_string, "TXT")                                                     \
+  V(duration_string, "duration")                                               \
+  V(emit_warning_string, "emitWarning")                                        \
+  V(exchange_string, "exchange")                                               \
+  V(encoding_string, "encoding")                                               \
+  V(entries_string, "entries")                                                 \
+  V(entry_type_string, "entryType")                                            \
+  V(env_pairs_string, "envPairs")                                              \
+  V(env_var_settings_string, "envVarSettings")                                 \
+  V(errno_string, "errno")                                                     \
+  V(error_string, "error")                                                     \
+  V(exit_code_string, "exitCode")                                              \
+  V(expire_string, "expire")                                                   \
+  V(exponent_string, "exponent")                                               \
+  V(exports_string, "exports")                                                 \
+  V(ext_key_usage_string, "ext_key_usage")                                     \
+  V(external_stream_string, "_externalStream")                                 \
+  V(family_string, "family")                                                   \
+  V(fatal_exception_string, "_fatalException")                                 \
+  V(fd_string, "fd")                                                           \
+  V(file_string, "file")                                                       \
+  V(fingerprint_string, "fingerprint")                                         \
+  V(fingerprint256_string, "fingerprint256")                                   \
+  V(flags_string, "flags")                                                     \
+  V(fragment_string, "fragment")                                               \
+  V(get_data_clone_error_string, "_getDataCloneError")                         \
+  V(get_shared_array_buffer_id_string, "_getSharedArrayBufferId")              \
+  V(gid_string, "gid")                                                         \
+  V(handle_string, "handle")                                                   \
+  V(help_text_string, "helpText")                                              \
+  V(homedir_string, "homedir")                                                 \
+  V(host_string, "host")                                                       \
+  V(hostmaster_string, "hostmaster")                                           \
+  V(ignore_string, "ignore")                                                   \
+  V(infoaccess_string, "infoAccess")                                           \
+  V(inherit_string, "inherit")                                                 \
+  V(input_string, "input")                                                     \
+  V(internal_string, "internal")                                               \
+  V(internal_binding_string, "internalBinding")                                \
+  V(ipv4_string, "IPv4")                                                       \
+  V(ipv6_string, "IPv6")                                                       \
+  V(isclosing_string, "isClosing")                                             \
+  V(issuer_string, "issuer")                                                   \
+  V(issuercert_string, "issuerCertificate")                                    \
+  V(kill_signal_string, "killSignal")                                          \
+  V(kind_string, "kind")                                                       \
+  V(mac_string, "mac")                                                         \
+  V(main_string, "main")                                                       \
+  V(max_buffer_string, "maxBuffer")                                            \
+  V(message_string, "message")                                                 \
+  V(message_port_string, "messagePort")                                        \
+  V(message_port_constructor_string, "MessagePort")                            \
+  V(minttl_string, "minttl")                                                   \
+  V(module_string, "module")                                                   \
+  V(modulus_string, "modulus")                                                 \
+  V(name_string, "name")                                                       \
+  V(netmask_string, "netmask")                                                 \
+  V(nsname_string, "nsname")                                                   \
+  V(ocsp_request_string, "OCSPRequest")                                        \
+  V(onaltsvc_string, "onaltsvc")                                               \
+  V(onchange_string, "onchange")                                               \
+  V(onclienthello_string, "onclienthello")                                     \
+  V(oncomplete_string, "oncomplete")                                           \
+  V(onconnection_string, "onconnection")                                       \
+  V(ondone_string, "ondone")                                                   \
+  V(onerror_string, "onerror")                                                 \
+  V(onexit_string, "onexit")                                                   \
+  V(onframeerror_string, "onframeerror")                                       \
+  V(ongetpadding_string, "ongetpadding")                                       \
+  V(onhandshakedone_string, "onhandshakedone")                                 \
+  V(onhandshakestart_string, "onhandshakestart")                               \
+  V(onheaders_string, "onheaders")                                             \
+  V(onmessage_string, "onmessage")                                             \
+  V(onnewsession_string, "onnewsession")                                       \
+  V(onocspresponse_string, "onocspresponse")                                   \
+  V(ongoawaydata_string, "ongoawaydata")                                       \
+  V(onorigin_string, "onorigin")                                               \
+  V(onpriority_string, "onpriority")                                           \
+  V(onread_string, "onread")                                                   \
+  V(onreadstart_string, "onreadstart")                                         \
+  V(onreadstop_string, "onreadstop")                                           \
+  V(onping_string, "onping")                                                   \
+  V(onsettings_string, "onsettings")                                           \
+  V(onshutdown_string, "onshutdown")                                           \
+  V(onsignal_string, "onsignal")                                               \
+  V(onstreamclose_string, "onstreamclose")                                     \
+  V(ontrailers_string, "ontrailers")                                           \
+  V(onunpipe_string, "onunpipe")                                               \
+  V(onwrite_string, "onwrite")                                                 \
+  V(openssl_error_stack, "opensslErrorStack")                                  \
+  V(options_string, "options")                                                 \
+  V(output_string, "output")                                                   \
+  V(order_string, "order")                                                     \
+  V(parse_error_string, "Parse Error")                                         \
+  V(password_string, "password")                                               \
+  V(path_string, "path")                                                       \
+  V(pending_handle_string, "pendingHandle")                                    \
+  V(pid_string, "pid")                                                         \
+  V(pipe_string, "pipe")                                                       \
+  V(pipe_target_string, "pipeTarget")                                          \
+  V(pipe_source_string, "pipeSource")                                          \
+  V(port_string, "port")                                                       \
+  V(port1_string, "port1")                                                     \
+  V(port2_string, "port2")                                                     \
+  V(preference_string, "preference")                                           \
+  V(priority_string, "priority")                                               \
+  V(process_string, "process")                                                 \
+  V(promise_string, "promise")                                                 \
+  V(pubkey_string, "pubkey")                                                   \
+  V(query_string, "query")                                                     \
+  V(raw_string, "raw")                                                         \
+  V(read_host_object_string, "_readHostObject")                                \
+  V(readable_string, "readable")                                               \
+  V(reason_string, "reason")                                                   \
+  V(refresh_string, "refresh")                                                 \
+  V(regexp_string, "regexp")                                                   \
+  V(rename_string, "rename")                                                   \
+  V(replacement_string, "replacement")                                         \
+  V(require_string, "require")                                                 \
+  V(retry_string, "retry")                                                     \
+  V(scheme_string, "scheme")                                                   \
+  V(serial_string, "serial")                                                   \
+  V(scopeid_string, "scopeid")                                                 \
+  V(serial_number_string, "serialNumber")                                      \
+  V(service_string, "service")                                                 \
+  V(servername_string, "servername")                                           \
+  V(session_id_string, "sessionId")                                            \
+  V(shell_string, "shell")                                                     \
+  V(signal_string, "signal")                                                   \
+  V(sink_string, "sink")                                                       \
+  V(size_string, "size")                                                       \
+  V(sni_context_err_string, "Invalid SNI context")                             \
+  V(sni_context_string, "sni_context")                                         \
+  V(source_string, "source")                                                   \
+  V(stack_string, "stack")                                                     \
+  V(start_time_string, "startTime")                                            \
+  V(status_string, "status")                                                   \
+  V(stdio_string, "stdio")                                                     \
+  V(subject_string, "subject")                                                 \
+  V(subjectaltname_string, "subjectaltname")                                   \
+  V(syscall_string, "syscall")                                                 \
+  V(thread_id_string, "threadId")                                              \
+  V(ticketkeycallback_string, "onticketkeycallback")                           \
+  V(timeout_string, "timeout")                                                 \
+  V(tls_ticket_string, "tlsTicket")                                            \
+  V(ttl_string, "ttl")                                                         \
+  V(type_string, "type")                                                       \
+  V(uid_string, "uid")                                                         \
+  V(unknown_string, "<unknown>")                                               \
+  V(url_string, "url")                                                         \
+  V(username_string, "username")                                               \
+  V(valid_from_string, "valid_from")                                           \
+  V(valid_to_string, "valid_to")                                               \
+  V(value_string, "value")                                                     \
+  V(verify_error_string, "verifyError")                                        \
+  V(version_string, "version")                                                 \
+  V(weight_string, "weight")                                                   \
+  V(windows_hide_string, "windowsHide")                                        \
+  V(windows_verbatim_arguments_string, "windowsVerbatimArguments")             \
+  V(wrap_string, "wrap")                                                       \
+  V(writable_string, "writable")                                               \
+  V(write_host_object_string, "_writeHostObject")                              \
+  V(write_queue_size_string, "writeQueueSize")                                 \
+  V(x_forwarded_string, "x-forwarded-for")                                     \
   V(zero_return_string, "ZERO_RETURN")
 
-#define ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)                           \
-  V(as_external, v8::External)                                                \
-  V(async_hooks_after_function, v8::Function)                                 \
-  V(async_hooks_before_function, v8::Function)                                \
-  V(async_hooks_binding, v8::Object)                                          \
-  V(async_hooks_destroy_function, v8::Function)                               \
-  V(async_hooks_init_function, v8::Function)                                  \
-  V(async_hooks_promise_resolve_function, v8::Function)                       \
-  V(async_wrap_object_ctor_template, v8::FunctionTemplate)                    \
-  V(async_wrap_ctor_template, v8::FunctionTemplate)                           \
-  V(buffer_prototype_object, v8::Object)                                      \
-  V(context, v8::Context)                                                     \
-  V(domain_callback, v8::Function)                                            \
-  V(domexception_function, v8::Function)                                      \
-  V(fdclose_constructor_template, v8::ObjectTemplate)                         \
-  V(fd_constructor_template, v8::ObjectTemplate)                              \
-  V(filehandlereadwrap_template, v8::ObjectTemplate)                          \
-  V(fsreqpromise_constructor_template, v8::ObjectTemplate)                    \
-  V(fs_use_promises_symbol, v8::Symbol)                                       \
-  V(handle_wrap_ctor_template, v8::FunctionTemplate)                          \
-  V(host_import_module_dynamically_callback, v8::Function)                    \
-  V(host_initialize_import_meta_object_callback, v8::Function)                \
-  V(http2ping_constructor_template, v8::ObjectTemplate)                       \
-  V(http2settings_constructor_template, v8::ObjectTemplate)                   \
-  V(http2stream_constructor_template, v8::ObjectTemplate)                     \
-  V(immediate_callback_function, v8::Function)                                \
-  V(inspector_console_api_object, v8::Object)                                 \
-  V(libuv_stream_wrap_ctor_template, v8::FunctionTemplate)                    \
-  V(message_port, v8::Object)                                                 \
-  V(message_port_constructor_template, v8::FunctionTemplate)                  \
-  V(pipe_constructor_template, v8::FunctionTemplate)                          \
-  V(performance_entry_callback, v8::Function)                                 \
-  V(performance_entry_template, v8::Function)                                 \
-  V(process_object, v8::Object)                                               \
-  V(promise_handler_function, v8::Function)                                   \
-  V(promise_wrap_template, v8::ObjectTemplate)                                \
-  V(sab_lifetimepartner_constructor_template, v8::FunctionTemplate)           \
-  V(script_context_constructor_template, v8::FunctionTemplate)                \
-  V(script_data_constructor_function, v8::Function)                           \
-  V(secure_context_constructor_template, v8::FunctionTemplate)                \
-  V(shutdown_wrap_template, v8::ObjectTemplate)                               \
-  V(tcp_constructor_template, v8::FunctionTemplate)                           \
-  V(tick_callback_function, v8::Function)                                     \
-  V(timers_callback_function, v8::Function)                                   \
-  V(tls_wrap_constructor_function, v8::Function)                              \
-  V(trace_category_state_function, v8::Function)                              \
-  V(tty_constructor_template, v8::FunctionTemplate)                           \
-  V(udp_constructor_function, v8::Function)                                   \
-  V(url_constructor_function, v8::Function)                                   \
+#define ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)                            \
+  V(as_external, v8::External)                                                 \
+  V(async_hooks_after_function, v8::Function)                                  \
+  V(async_hooks_before_function, v8::Function)                                 \
+  V(async_hooks_binding, v8::Object)                                           \
+  V(async_hooks_destroy_function, v8::Function)                                \
+  V(async_hooks_init_function, v8::Function)                                   \
+  V(async_hooks_promise_resolve_function, v8::Function)                        \
+  V(async_wrap_object_ctor_template, v8::FunctionTemplate)                     \
+  V(async_wrap_ctor_template, v8::FunctionTemplate)                            \
+  V(buffer_prototype_object, v8::Object)                                       \
+  V(context, v8::Context)                                                      \
+  V(domain_callback, v8::Function)                                             \
+  V(domexception_function, v8::Function)                                       \
+  V(fdclose_constructor_template, v8::ObjectTemplate)                          \
+  V(fd_constructor_template, v8::ObjectTemplate)                               \
+  V(filehandlereadwrap_template, v8::ObjectTemplate)                           \
+  V(fsreqpromise_constructor_template, v8::ObjectTemplate)                     \
+  V(fs_use_promises_symbol, v8::Symbol)                                        \
+  V(handle_wrap_ctor_template, v8::FunctionTemplate)                           \
+  V(host_import_module_dynamically_callback, v8::Function)                     \
+  V(host_initialize_import_meta_object_callback, v8::Function)                 \
+  V(http2ping_constructor_template, v8::ObjectTemplate)                        \
+  V(http2settings_constructor_template, v8::ObjectTemplate)                    \
+  V(http2stream_constructor_template, v8::ObjectTemplate)                      \
+  V(immediate_callback_function, v8::Function)                                 \
+  V(inspector_console_api_object, v8::Object)                                  \
+  V(libuv_stream_wrap_ctor_template, v8::FunctionTemplate)                     \
+  V(message_port, v8::Object)                                                  \
+  V(message_port_constructor_template, v8::FunctionTemplate)                   \
+  V(native_modules_code_cache, v8::Object)                                     \
+  V(native_modules_code_cache_hash, v8::Object)                                \
+  V(native_modules_source, v8::Object)                                         \
+  V(native_modules_source_hash, v8::Object)                                    \
+  V(native_modules_with_cache, v8::Set)                                        \
+  V(native_modules_without_cache, v8::Set)                                     \
+  V(pipe_constructor_template, v8::FunctionTemplate)                           \
+  V(performance_entry_callback, v8::Function)                                  \
+  V(performance_entry_template, v8::Function)                                  \
+  V(process_object, v8::Object)                                                \
+  V(promise_handler_function, v8::Function)                                    \
+  V(promise_wrap_template, v8::ObjectTemplate)                                 \
+  V(sab_lifetimepartner_constructor_template, v8::FunctionTemplate)            \
+  V(script_context_constructor_template, v8::FunctionTemplate)                 \
+  V(script_data_constructor_function, v8::Function)                            \
+  V(secure_context_constructor_template, v8::FunctionTemplate)                 \
+  V(shutdown_wrap_template, v8::ObjectTemplate)                                \
+  V(tcp_constructor_template, v8::FunctionTemplate)                            \
+  V(tick_callback_function, v8::Function)                                      \
+  V(timers_callback_function, v8::Function)                                    \
+  V(tls_wrap_constructor_function, v8::Function)                               \
+  V(trace_category_state_function, v8::Function)                               \
+  V(tty_constructor_template, v8::FunctionTemplate)                            \
+  V(udp_constructor_function, v8::Function)                                    \
+  V(url_constructor_function, v8::Function)                                    \
   V(write_wrap_template, v8::ObjectTemplate)
 
 class Environment;
diff --git a/src/node.cc b/src/node.cc
index d4272bea20144d..48e8f0a2497700 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -25,10 +25,9 @@
 #include "node_errors.h"
 #include "node_internals.h"
 #include "node_javascript.h"
-#include "node_code_cache.h"
+#include "node_native_module.h"
+#include "node_perf.h"
 #include "node_platform.h"
-#include "node_version.h"
-#include "node_internals.h"
 #include "node_revert.h"
 #include "node_version.h"
 #include "tracing/traced_value.h"
@@ -131,6 +130,7 @@ typedef int mode_t;
 
 namespace node {
 
+using native_module::NativeModule;
 using options_parser::kAllowedInEnvironment;
 using options_parser::kDisallowedInEnvironment;
 using v8::Array;
@@ -775,6 +775,7 @@ static MaybeLocal<Value> ExecuteString(Environment* env,
   try_catch.SetVerbose(false);
 
   ScriptOrigin origin(filename);
+
   MaybeLocal<Script> script =
       Script::Compile(env->context(), source, &origin);
   if (script.IsEmpty()) {
@@ -1222,19 +1223,7 @@ static void GetInternalBinding(const FunctionCallbackInfo<Value>& args) {
     DefineConstants(env->isolate(), exports);
   } else if (!strcmp(*module_v, "natives")) {
     exports = Object::New(env->isolate());
-    DefineJavaScript(env, exports);
-  } else if (!strcmp(*module_v, "code_cache")) {
-    // internalBinding('code_cache')
-    exports = Object::New(env->isolate());
-    DefineCodeCache(env, exports);
-  } else if (!strcmp(*module_v, "code_cache_hash")) {
-    // internalBinding('code_cache_hash')
-    exports = Object::New(env->isolate());
-    DefineCodeCacheHash(env, exports);
-  } else if (!strcmp(*module_v, "natives_hash")) {
-    // internalBinding('natives_hash')
-    exports = Object::New(env->isolate());
-    DefineJavaScriptHash(env, exports);
+    NativeModule::GetNatives(env, exports);
   } else {
     return ThrowIfNoSuchModule(env, *module_v);
   }
@@ -1772,6 +1761,8 @@ void LoadEnvironment(Environment* env) {
   // lib/internal/bootstrap/node.js, each included as a static C string
   // defined in node_javascript.h, generated in node_javascript.cc by
   // node_js2c.
+
+  // TODO(joyeecheung): use NativeModule::Compile
   Local<String> loaders_name =
       FIXED_ONE_BYTE_STRING(env->isolate(), "internal/bootstrap/loaders.js");
   MaybeLocal<Function> loaders_bootstrapper =
@@ -1831,6 +1822,8 @@ void LoadEnvironment(Environment* env) {
                  env->options()->debug_options->break_node_first_line)
   };
 
+  NativeModule::LoadBindings(env);
+
   // Bootstrap internal loaders
   Local<Value> bootstrapped_loaders;
   if (!ExecuteBootstrapper(env, loaders_bootstrapper.ToLocalChecked(),
@@ -2484,6 +2477,8 @@ Local<Context> NewContext(Isolate* isolate,
   {
     // Run lib/internal/per_context.js
     Context::Scope context_scope(context);
+
+    // TODO(joyeecheung): use NativeModule::Compile
     Local<String> per_context = NodePerContextSource(isolate);
     ScriptCompiler::Source per_context_src(per_context, nullptr);
     Local<Script> s = ScriptCompiler::Compile(
diff --git a/src/node_code_cache.h b/src/node_code_cache.h
index db8012286172a9..8054279d55ba96 100644
--- a/src/node_code_cache.h
+++ b/src/node_code_cache.h
@@ -7,6 +7,8 @@
 
 namespace node {
 
+extern const bool native_module_has_code_cache;
+
 void DefineCodeCache(Environment* env, v8::Local<v8::Object> target);
 void DefineCodeCacheHash(Environment* env, v8::Local<v8::Object> target);
 
diff --git a/src/node_code_cache_stub.cc b/src/node_code_cache_stub.cc
index 35780e13f026b0..2fb86c5bf769f5 100644
--- a/src/node_code_cache_stub.cc
+++ b/src/node_code_cache_stub.cc
@@ -5,6 +5,9 @@
 // The stub here is used when configure is run without `--code-cache-path`
 
 namespace node {
+
+const bool native_module_has_code_cache = false;
+
 void DefineCodeCache(Environment* env, v8::Local<v8::Object> target) {
   // When we do not produce code cache for builtin modules,
   // `internalBinding('code_cache')` returns an empty object
diff --git a/src/node_internals.h b/src/node_internals.h
index b026a968430808..b6cd628086dcb2 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -118,6 +118,7 @@ struct sockaddr;
   V(js_stream)                                                                 \
   V(messaging)                                                                 \
   V(module_wrap)                                                               \
+  V(native_module)                                                             \
   V(options)                                                                   \
   V(os)                                                                        \
   V(performance)                                                               \
diff --git a/src/node_native_module.cc b/src/node_native_module.cc
new file mode 100644
index 00000000000000..ea7fe9189a6857
--- /dev/null
+++ b/src/node_native_module.cc
@@ -0,0 +1,326 @@
+#include "node_native_module.h"
+#include "node_code_cache.h"
+#include "node_errors.h"
+#include "node_javascript.h"
+
+namespace node {
+namespace native_module {
+
+using v8::Array;
+using v8::ArrayBuffer;
+using v8::Context;
+using v8::EscapableHandleScope;
+using v8::Function;
+using v8::FunctionCallbackInfo;
+using v8::HandleScope;
+using v8::Integer;
+using v8::IntegrityLevel;
+using v8::Isolate;
+using v8::Local;
+using v8::Maybe;
+using v8::MaybeLocal;
+using v8::Object;
+using v8::Script;
+using v8::ScriptCompiler;
+using v8::ScriptOrigin;
+using v8::Set;
+using v8::String;
+using v8::TryCatch;
+using v8::Uint8Array;
+using v8::Value;
+
+void NativeModule::GetNatives(Environment* env, Local<Object> exports) {
+  DefineJavaScript(env, exports);
+}
+
+void NativeModule::LoadBindings(Environment* env) {
+  // TODO(joyeecheung): put the static values into a
+  // std::map<std::string, const uint8_t*> instead of a v8::Object,
+  // because here they are only looked up from the C++ side
+  // (except in process.binding('natives') which we don't use)
+  // so there is little value to put them in a v8::Object upfront.
+  // Moreover, a std::map lookup should be faster than a lookup on
+  // an V8 Object in dictionary mode.
+  Isolate* isolate = env->isolate();
+  Local<Context> context = env->context();
+  Local<Value> null = Null(isolate);
+
+  Local<Object> native_modules_source = Object::New(isolate);
+  CHECK(native_modules_source->SetPrototype(context, null).FromJust());
+  DefineJavaScript(env, native_modules_source);
+  native_modules_source->SetIntegrityLevel(context, IntegrityLevel::kFrozen)
+      .FromJust();
+  env->set_native_modules_source(native_modules_source);
+
+  Local<Object> native_modules_source_hash = Object::New(isolate);
+  CHECK(native_modules_source_hash->SetPrototype(context, null).FromJust());
+  DefineJavaScriptHash(env, native_modules_source_hash);
+  native_modules_source_hash
+      ->SetIntegrityLevel(context, IntegrityLevel::kFrozen)
+      .FromJust();
+  env->set_native_modules_source_hash(native_modules_source_hash);
+
+  Local<Object> native_modules_code_cache = Object::New(isolate);
+  CHECK(native_modules_code_cache->SetPrototype(context, null).FromJust());
+  DefineCodeCache(env, native_modules_code_cache);
+  native_modules_code_cache->SetIntegrityLevel(context, IntegrityLevel::kFrozen)
+      .FromJust();
+  env->set_native_modules_code_cache(native_modules_code_cache);
+
+  Local<Object> native_modules_code_cache_hash = Object::New(isolate);
+  CHECK(native_modules_code_cache_hash->SetPrototype(context, null).FromJust());
+  DefineCodeCacheHash(env, native_modules_code_cache_hash);
+  native_modules_code_cache_hash
+      ->SetIntegrityLevel(context, IntegrityLevel::kFrozen)
+      .FromJust();
+  env->set_native_modules_code_cache_hash(native_modules_code_cache_hash);
+
+  env->set_native_modules_with_cache(Set::New(isolate));
+  env->set_native_modules_without_cache(Set::New(isolate));
+}
+
+void NativeModule::CompileCodeCache(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(args[0]->IsString());
+  Local<String> id = args[0].As<String>();
+
+  Local<Value> result = CompileAsModule(env, id, true);
+  if (!result.IsEmpty()) {
+    args.GetReturnValue().Set(result);
+  }
+}
+
+void NativeModule::CompileFunction(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  CHECK(args[0]->IsString());
+  Local<String> id = args[0].As<String>();
+
+  Local<Value> result = CompileAsModule(env, id, false);
+  if (!result.IsEmpty()) {
+    args.GetReturnValue().Set(result);
+  }
+}
+
+Local<Value> NativeModule::CompileAsModule(Environment* env,
+                                           Local<String> id,
+                                           bool produce_code_cache) {
+  Local<String> parameters[] = {env->exports_string(),
+                                env->require_string(),
+                                env->module_string(),
+                                env->process_string(),
+                                env->internal_binding_string()};
+
+  return Compile(
+      env, id, parameters, arraysize(parameters), produce_code_cache);
+}
+
+// Currently V8 only checks that the length of the source code is the
+// same as the code used to generate the hash, so we add an additional
+// check here:
+// 1. During compile time, when generating node_javascript.cc and
+//    node_code_cache.cc, we compute and include the hash of the
+//    JavaScript source in both.
+// 2. At runtime, we check that the hash of the code being compiled
+//   and the hash of the code used to generate the cache
+//   (without the parameters) is the same.
+// This is based on the assumptions:
+// 1. `code_cache_hash` must be in sync with `code_cache`
+//     (both defined in node_code_cache.cc)
+// 2. `source_hash` must be in sync with `source`
+//     (both defined in node_javascript.cc)
+// 3. If `source_hash` is in sync with `code_cache_hash`,
+//    then the source code used to generate `code_cache`
+//    should be in sync with the source code in `source`
+// The only variable left, then, are the parameters passed to the
+// CompileFunctionInContext. If the parameters used generate the cache
+// is different from the one used to compile modules at run time, then
+// there could be false postivies, but that should be rare and should fail
+// early in the bootstrap process so it should be easy to detect and fix.
+
+// Returns nullptr if there is no code cache corresponding to the id
+ScriptCompiler::CachedData* GetCachedData(Environment* env, Local<String> id) {
+  HandleScope scope(env->isolate());
+  Local<Context> context = env->context();
+
+  Local<Value> result =
+      env->native_modules_code_cache()->Get(context, id).ToLocalChecked();
+  // This could be false if the module cannot be cached somehow.
+  // See lib/internal/bootstrap/cache.js on the modules that cannot be cached
+  if (result->IsUndefined()) {
+    return nullptr;
+  }
+
+  CHECK(result->IsUint8Array());
+  Local<Uint8Array> code_cache = result.As<Uint8Array>();
+
+  result =
+      env->native_modules_code_cache_hash()->Get(context, id).ToLocalChecked();
+  CHECK(result->IsString());
+  Local<String> code_cache_hash = result.As<String>();
+
+  result =
+      env->native_modules_source_hash()->Get(context, id).ToLocalChecked();
+  CHECK(result->IsString());
+  Local<String> source_hash = result.As<String>();
+
+  // It may fail when any of the inputs of the `node_js2c` target in
+  // node.gyp is modified but the tools/generate_code_cache.js
+  // is not re run.
+  // FIXME(joyeecheung): Figure out how to resolve the dependency issue.
+  // When the code cache was introduced we were at a point where refactoring
+  // node.gyp may not be worth the effort.
+  CHECK(code_cache_hash->StrictEquals(source_hash));
+
+  ArrayBuffer::Contents contents = code_cache->Buffer()->GetContents();
+  uint8_t* data = static_cast<uint8_t*>(contents.Data());
+  return new ScriptCompiler::CachedData(data + code_cache->ByteOffset(),
+                                        code_cache->ByteLength());
+}
+
+// Returns Local<Function> of the compiled module if produce_code_cache
+// is false (we are only compiling the function).
+// Otherwise return a Local<Object> containing the cache.
+Local<Value> NativeModule::Compile(Environment* env,
+                                   Local<String> id,
+                                   Local<String> parameters[],
+                                   size_t parameters_count,
+                                   bool produce_code_cache) {
+  EscapableHandleScope scope(env->isolate());
+  Local<Context> context = env->context();
+  Isolate* isolate = env->isolate();
+
+  Local<Value> result =
+      env->native_modules_source()->Get(context, id).ToLocalChecked();
+  CHECK(result->IsString());
+  Local<String> source = result.As<String>();
+
+  Local<String> filename =
+      String::Concat(isolate, id, FIXED_ONE_BYTE_STRING(isolate, ".js"));
+  Local<Integer> line_offset = Integer::New(isolate, 0);
+  Local<Integer> column_offset = Integer::New(isolate, 0);
+  ScriptOrigin origin(filename, line_offset, column_offset);
+
+  bool use_cache = false;
+  ScriptCompiler::CachedData* cached_data = nullptr;
+
+  // 1. We won't even check the existence of the cache if the binary is not
+  //    built with them.
+  // 2. If we are generating code cache for tools/general_code_cache.js, we
+  //    are not going to use any cache ourselves.
+  if (native_module_has_code_cache && !produce_code_cache) {
+    cached_data = GetCachedData(env, id);
+    if (cached_data != nullptr) {
+      use_cache = true;
+    }
+  }
+
+  ScriptCompiler::Source script_source(source, origin, cached_data);
+
+  ScriptCompiler::CompileOptions options;
+  if (produce_code_cache) {
+    options = ScriptCompiler::kEagerCompile;
+  } else if (use_cache) {
+    options = ScriptCompiler::kConsumeCodeCache;
+  } else {
+    options = ScriptCompiler::kNoCompileOptions;
+  }
+
+  MaybeLocal<Function> maybe_fun =
+      ScriptCompiler::CompileFunctionInContext(context,
+                                               &script_source,
+                                               parameters_count,
+                                               parameters,
+                                               0,
+                                               nullptr,
+                                               options);
+
+  TryCatch try_catch(isolate);
+  Local<Function> fun;
+  // This could fail when there are early errors in the native modules,
+  // e.g. the syntax errors
+  if (maybe_fun.IsEmpty() || !maybe_fun.ToLocal(&fun)) {
+    DecorateErrorStack(env, try_catch);
+    try_catch.ReThrow();
+    return scope.Escape(Local<Value>());
+  }
+
+  if (use_cache) {
+    // If the cache is rejected, something must be wrong with the build
+    // and we should just crash.
+    CHECK(!script_source.GetCachedData()->rejected);
+    if (env->native_modules_with_cache()->Add(context, id).IsEmpty()) {
+      return scope.Escape(Local<Value>());
+    }
+  } else {
+    if (env->native_modules_without_cache()->Add(context, id).IsEmpty()) {
+      return scope.Escape(Local<Value>());
+    }
+  }
+
+  if (produce_code_cache) {
+    std::unique_ptr<ScriptCompiler::CachedData> cached_data(
+        ScriptCompiler::CreateCodeCacheForFunction(fun));
+    CHECK_NE(cached_data, nullptr);
+    char* data =
+        reinterpret_cast<char*>(const_cast<uint8_t*>(cached_data->data));
+
+    // Since we have no API to create a buffer from a new'ed pointer,
+    // we will need to copy it - but this code path is only run by the
+    // tooling that generates the code cache to be bundled in the binary
+    // so it should be fine.
+    Local<Object> buf =
+        Buffer::Copy(env, data, cached_data->length).ToLocalChecked();
+    return scope.Escape(buf);
+  } else {
+    return scope.Escape(fun);
+  }
+}
+
+void Initialize(Local<Object> target,
+                Local<Value> unused,
+                Local<Context> context) {
+  Environment* env = Environment::GetCurrent(context);
+
+  target
+      ->Set(context,
+            FIXED_ONE_BYTE_STRING(env->isolate(), "source"),
+            env->native_modules_source())
+      .FromJust();
+  target
+      ->Set(context,
+            FIXED_ONE_BYTE_STRING(env->isolate(), "sourceHash"),
+            env->native_modules_source_hash())
+      .FromJust();
+  target
+      ->Set(context,
+            FIXED_ONE_BYTE_STRING(env->isolate(), "codeCache"),
+            env->native_modules_code_cache())
+      .FromJust();
+  target
+      ->Set(context,
+            FIXED_ONE_BYTE_STRING(env->isolate(), "codeCacheHash"),
+            env->native_modules_code_cache_hash())
+      .FromJust();
+  target
+      ->Set(context,
+            FIXED_ONE_BYTE_STRING(env->isolate(), "compiledWithCache"),
+            env->native_modules_with_cache())
+      .FromJust();
+  target
+      ->Set(context,
+            FIXED_ONE_BYTE_STRING(env->isolate(), "compiledWithoutCache"),
+            env->native_modules_without_cache())
+      .FromJust();
+
+  env->SetMethod(target, "compileFunction", NativeModule::CompileFunction);
+  env->SetMethod(target, "compileCodeCache", NativeModule::CompileCodeCache);
+  // internalBinding('native_module') should be frozen
+  target->SetIntegrityLevel(context, IntegrityLevel::kFrozen).FromJust();
+}
+
+}  // namespace native_module
+}  // namespace node
+
+NODE_MODULE_CONTEXT_AWARE_INTERNAL(native_module,
+                                   node::native_module::Initialize)
diff --git a/src/node_native_module.h b/src/node_native_module.h
new file mode 100644
index 00000000000000..c4ffbfb0cdf94d
--- /dev/null
+++ b/src/node_native_module.h
@@ -0,0 +1,41 @@
+#ifndef SRC_NODE_NATIVE_MODULE_H_
+#define SRC_NODE_NATIVE_MODULE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_internals.h"
+
+namespace node {
+namespace native_module {
+
+// The native (C++) side of the native module compilation.
+
+class NativeModule {
+ public:
+  // For legacy process.binding('natives') which is mutable
+  static void GetNatives(Environment* env, v8::Local<v8::Object> exports);
+  // Loads the static JavaScript source code and the cache into Environment
+  static void LoadBindings(Environment* env);
+  // Compile code cache for a specific native module
+  static void CompileCodeCache(const v8::FunctionCallbackInfo<v8::Value>& args);
+  // Compile a specific native module as a function
+  static void CompileFunction(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+ private:
+  static v8::Local<v8::Value> CompileAsModule(Environment* env,
+                                              v8::Local<v8::String> id,
+                                              bool produce_code_cache);
+  // TODO(joyeecheung): make this public and reuse it to compile bootstrappers
+  static v8::Local<v8::Value> Compile(Environment* env,
+                                      v8::Local<v8::String> id,
+                                      v8::Local<v8::String> parameters[],
+                                      size_t parameters_count,
+                                      bool produce_code_cache);
+};
+
+}  // namespace native_module
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_NATIVE_MODULE_H_
diff --git a/test/code-cache/test-code-cache.js b/test/code-cache/test-code-cache.js
index c1bfa80f4342f3..994facff1996c2 100644
--- a/test/code-cache/test-code-cache.js
+++ b/test/code-cache/test-code-cache.js
@@ -7,17 +7,28 @@
 
 require('../common');
 const assert = require('assert');
-const {
-  types: {
-    isUint8Array
-  }
-} = require('util');
 const {
   cachableBuiltins,
-  codeCache,
-  compiledWithCache,
-  compiledWithoutCache
+  cannotUseCache
 } = require('internal/bootstrap/cache');
+const {
+  isMainThread
+} = require('worker_threads');
+
+const {
+  internalBinding
+} = require('internal/test/binding');
+const {
+  compiledWithoutCache,
+  compiledWithCache
+} = internalBinding('native_module');
+
+for (const key of cachableBuiltins) {
+  if (!isMainThread && key === 'trace_events') {
+    continue;  // Cannot load trace_events in workers
+  }
+  require(key);
+}
 
 const loadedModules = process.moduleLoadList
   .filter((m) => m.startsWith('NativeModule'))
@@ -26,29 +37,23 @@ const loadedModules = process.moduleLoadList
 // The binary is not configured with code cache, verifies that the builtins
 // are all compiled without cache and we are doing the bookkeeping right.
 if (process.config.variables.node_code_cache_path === undefined) {
-  assert.deepStrictEqual(compiledWithCache, []);
-  assert.notStrictEqual(compiledWithoutCache.length, 0);
-
-  for (const key of loadedModules) {
-    assert(compiledWithoutCache.includes(key),
-           `"${key}" should not have been compiled with code cache`);
-  }
-
+  console.log('The binary is not configured with code cache');
+  assert.deepStrictEqual(compiledWithCache, new Set());
+  assert.deepStrictEqual(compiledWithoutCache, new Set(loadedModules));
 } else {
-  // The binary is configured with code cache.
+  console.log('The binary is configured with code cache');
   assert.strictEqual(
     typeof process.config.variables.node_code_cache_path,
     'string'
   );
-  assert.deepStrictEqual(compiledWithoutCache, []);
 
   for (const key of loadedModules) {
-    assert(compiledWithCache.includes(key),
-           `"${key}" should've been compiled with code cache`);
-  }
-
-  for (const key of cachableBuiltins) {
-    assert(isUint8Array(codeCache[key]) && codeCache[key].length > 0,
-           `Code cache for "${key}" should've been generated`);
+    if (cannotUseCache.includes(key)) {
+      assert(compiledWithoutCache.has(key),
+             `"${key}" should've been compiled without code cache`);
+    } else {
+      assert(compiledWithCache.has(key),
+             `"${key}" should've been compiled with code cache`);
+    }
   }
 }
diff --git a/tools/generate_code_cache.js b/tools/generate_code_cache.js
index 35411bc5af182a..9609d77c2afca9 100644
--- a/tools/generate_code_cache.js
+++ b/tools/generate_code_cache.js
@@ -8,8 +8,8 @@
 // of `configure`.
 
 const {
-  getCodeCache,
   getSource,
+  getCodeCache,
   cachableBuiltins
 } = require('internal/bootstrap/cache');
 
@@ -118,6 +118,8 @@ namespace node {
 
 ${cacheDefinitions.join('\n\n')}
 
+const bool native_module_has_code_cache = true;
+
 // The target here will be returned as \`internalBinding('code_cache')\`
 void DefineCodeCache(Environment* env, v8::Local<v8::Object> target) {
   v8::Isolate* isolate = env->isolate();