diff --git a/doc/api/cli.md b/doc/api/cli.md
index 4bf6a9473a0350..5f4faff2313647 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -190,6 +190,13 @@ added: v12.3.0
 
 Enable experimental WebAssembly module support.
 
+### `--experimental-wasi-modules`
+<!-- YAML
+added: REPLACEME
+-->
+
+Enable experimental [WASI][] module support.
+
 ### `--force-fips`
 <!-- YAML
 added: v6.0.0
@@ -1208,3 +1215,4 @@ greater than `4` (its current default value). For more information, see the
 [experimental ECMAScript Module]: esm.html#esm_resolve_hook
 [libuv threadpool documentation]: http://docs.libuv.org/en/latest/threadpool.html
 [remote code execution]: https://www.owasp.org/index.php/Code_Injection
+[WASI]: https://wasi.dev
diff --git a/doc/api/esm.md b/doc/api/esm.md
index c4edc523571336..b928c631f45f1e 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -449,6 +449,11 @@ node --experimental-modules --experimental-wasm-modules index.mjs
 
 would provide the exports interface for the instantiation of `module.wasm`.
 
+### WASI
+
+Additionally, if `--experimental-wasi-modules` is passed, Wasm modules
+conforming to [WASI][] specification will be run.
+
 ## Experimental Loader hooks
 
 **Note: This API is currently being redesigned and will still change.**
@@ -749,3 +754,4 @@ success!
 [ES Module Integration Proposal for Web Assembly]: https://github.com/webassembly/esm-integration
 [dynamic instantiate hook]: #esm_dynamic_instantiate_hook
 [the official standard format]: https://tc39.github.io/ecma262/#sec-modules
+[WASI]: https://wasi.dev
diff --git a/lib/internal/modules/esm/create_dynamic_module.js b/lib/internal/modules/esm/create_dynamic_module.js
index 1201820003984f..e1c48f4e0d895b 100644
--- a/lib/internal/modules/esm/create_dynamic_module.js
+++ b/lib/internal/modules/esm/create_dynamic_module.js
@@ -36,8 +36,7 @@ import.meta.done();
     onReady: (cb) => { readyfns.add(cb); },
   };
 
-  if (imports.length)
-    reflect.imports = Object.create(null);
+  reflect.imports = Object.create(null);
 
   callbackMap.set(m, {
     initializeImportMeta: (meta, wrap) => {
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index b1f2c9f2595fc7..b296609996587b 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -6,7 +6,7 @@ const {
   JSON,
   Object,
   SafeMap,
-  StringPrototype
+  StringPrototype,
 } = primordials;
 
 const { NativeModule } = require('internal/bootstrap/loaders');
@@ -22,9 +22,11 @@ const { fileURLToPath, URL } = require('url');
 const { debuglog } = require('internal/util/debuglog');
 const { promisify } = require('internal/util');
 const esmLoader = require('internal/process/esm_loader');
+const { getOptionValue } = require('internal/options');
 const {
   ERR_UNKNOWN_BUILTIN_MODULE
 } = require('internal/errors').codes;
+const WASI = require('internal/wasi');
 const readFileAsync = promisify(fs.readFile);
 const JsonParse = JSON.parse;
 
@@ -154,6 +156,8 @@ translators.set('json', async function jsonStrategy(url) {
   });
 });
 
+const wasiEnabled = getOptionValue('--experimental-wasi-modules');
+
 // Strategy for loading a wasm module
 translators.set('wasm', async function(url) {
   const pathname = fileURLToPath(url);
@@ -167,13 +171,37 @@ translators.set('wasm', async function(url) {
     throw err;
   }
 
-  const imports =
-      WebAssembly.Module.imports(compiled).map(({ module }) => module);
+  let usesWasi = false;
+  const imports = WebAssembly.Module.imports(compiled)
+    .reduce((acc, { module }) => {
+      if (wasiEnabled && module === 'wasi_unstable') {
+        usesWasi = true;
+      } else {
+        acc.push(module);
+      }
+      return acc;
+    }, []);
   const exports = WebAssembly.Module.exports(compiled).map(({ name }) => name);
 
   return createDynamicModule(imports, exports, url, (reflect) => {
+    let wasi;
+    if (usesWasi) {
+      wasi = new WASI(WASI.defaultConfig);
+      reflect.imports.wasi_unstable = wasi.exports;
+    }
+
     const { exports } = new WebAssembly.Instance(compiled, reflect.imports);
     for (const expt of Object.keys(exports))
       reflect.exports[expt].set(exports[expt]);
+
+    if (usesWasi && exports.memory) {
+      wasi.setMemory(exports.memory);
+    }
+
+    if (exports._start) {
+      exports._start();
+    } else if (exports.__wasi_unstable_reactor_start) {
+      exports.__wasi_unstable_reactor_start();
+    }
   });
 });
diff --git a/lib/internal/wasi.js b/lib/internal/wasi.js
new file mode 100644
index 00000000000000..af53274688e054
--- /dev/null
+++ b/lib/internal/wasi.js
@@ -0,0 +1,1294 @@
+'use strict';
+
+/* eslint-disable no-unused-vars */
+
+const binding = internalBinding('wasi');
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const perfHooks = require('perf_hooks');
+const { isatty: isTTY } = require('tty');
+const { Buffer } = require('buffer');
+const { Object, Math } = primordials;
+
+const WASI_ESUCCESS = 0;
+const WASI_E2BIG = 1;
+const WASI_EACCES = 2;
+const WASI_EADDRINUSE = 3;
+const WASI_EADDRNOTAVAIL = 4;
+const WASI_EAFNOSUPPORT = 5;
+const WASI_EAGAIN = 6;
+const WASI_EALREADY = 7;
+const WASI_EBADF = 8;
+const WASI_EBADMSG = 9;
+const WASI_EBUSY = 10;
+const WASI_ECANCELED = 11;
+const WASI_ECHILD = 12;
+const WASI_ECONNABORTED = 13;
+const WASI_ECONNREFUSED = 14;
+const WASI_ECONNRESET = 15;
+const WASI_EDEADLK = 16;
+const WASI_EDESTADDRREQ = 17;
+const WASI_EDOM = 18;
+const WASI_EDQUOT = 19;
+const WASI_EEXIST = 20;
+const WASI_EFAULT = 21;
+const WASI_EFBIG = 22;
+const WASI_EHOSTUNREACH = 23;
+const WASI_EIDRM = 24;
+const WASI_EILSEQ = 25;
+const WASI_EINPROGRESS = 26;
+const WASI_EINTR = 27;
+const WASI_EINVAL = 28;
+const WASI_EIO = 29;
+const WASI_EISCONN = 30;
+const WASI_EISDIR = 31;
+const WASI_ELOOP = 32;
+const WASI_EMFILE = 33;
+const WASI_EMLINK = 34;
+const WASI_EMSGSIZE = 35;
+const WASI_EMULTIHOP = 36;
+const WASI_ENAMETOOLONG = 37;
+const WASI_ENETDOWN = 38;
+const WASI_ENETRESET = 39;
+const WASI_ENETUNREACH = 40;
+const WASI_ENFILE = 41;
+const WASI_ENOBUFS = 42;
+const WASI_ENODEV = 43;
+const WASI_ENOENT = 44;
+const WASI_ENOEXEC = 45;
+const WASI_ENOLCK = 46;
+const WASI_ENOLINK = 47;
+const WASI_ENOMEM = 48;
+const WASI_ENOMSG = 49;
+const WASI_ENOPROTOOPT = 50;
+const WASI_ENOSPC = 51;
+const WASI_ENOSYS = 52;
+const WASI_ENOTCONN = 53;
+const WASI_ENOTDIR = 54;
+const WASI_ENOTEMPTY = 55;
+const WASI_ENOTRECOVERABLE = 56;
+const WASI_ENOTSOCK = 57;
+const WASI_ENOTSUP = 58;
+const WASI_ENOTTY = 59;
+const WASI_ENXIO = 60;
+const WASI_EOVERFLOW = 61;
+const WASI_EOWNERDEAD = 62;
+const WASI_EPERM = 63;
+const WASI_EPIPE = 64;
+const WASI_EPROTO = 65;
+const WASI_EPROTONOSUPPORT = 66;
+const WASI_EPROTOTYPE = 67;
+const WASI_ERANGE = 68;
+const WASI_EROFS = 69;
+const WASI_ESPIPE = 70;
+const WASI_ESRCH = 71;
+const WASI_ESTALE = 72;
+const WASI_ETIMEDOUT = 73;
+const WASI_ETXTBSY = 74;
+const WASI_EXDEV = 75;
+const WASI_ENOTCAPABLE = 76;
+
+const WASI_SIGABRT = 0;
+const WASI_SIGALRM = 1;
+const WASI_SIGBUS = 2;
+const WASI_SIGCHLD = 3;
+const WASI_SIGCONT = 4;
+const WASI_SIGFPE = 5;
+const WASI_SIGHUP = 6;
+const WASI_SIGILL = 7;
+const WASI_SIGINT = 8;
+const WASI_SIGKILL = 9;
+const WASI_SIGPIPE = 10;
+const WASI_SIGQUIT = 11;
+const WASI_SIGSEGV = 12;
+const WASI_SIGSTOP = 13;
+const WASI_SIGTERM = 14;
+const WASI_SIGTRAP = 15;
+const WASI_SIGTSTP = 16;
+const WASI_SIGTTIN = 17;
+const WASI_SIGTTOU = 18;
+const WASI_SIGURG = 19;
+const WASI_SIGUSR1 = 20;
+const WASI_SIGUSR2 = 21;
+const WASI_SIGVTALRM = 22;
+const WASI_SIGXCPU = 23;
+const WASI_SIGXFSZ = 24;
+
+const WASI_FILETYPE_UNKNOWN = 0;
+const WASI_FILETYPE_BLOCK_DEVICE = 1;
+const WASI_FILETYPE_CHARACTER_DEVICE = 2;
+const WASI_FILETYPE_DIRECTORY = 3;
+const WASI_FILETYPE_REGULAR_FILE = 4;
+const WASI_FILETYPE_SOCKET_DGRAM = 5;
+const WASI_FILETYPE_SOCKET_STREAM = 6;
+const WASI_FILETYPE_SYMBOLIC_LINK = 7;
+
+const WASI_FDFLAG_APPEND = 0x0001;
+const WASI_FDFLAG_DSYNC = 0x0002;
+const WASI_FDFLAG_NONBLOCK = 0x0004;
+const WASI_FDFLAG_RSYNC = 0x0008;
+const WASI_FDFLAG_SYNC = 0x0010;
+
+const WASI_RIGHT_FD_DATASYNC = 0x0000000000000001n;
+const WASI_RIGHT_FD_READ = 0x0000000000000002n;
+const WASI_RIGHT_FD_SEEK = 0x0000000000000004n;
+const WASI_RIGHT_FD_FDSTAT_SET_FLAGS = 0x0000000000000008n;
+const WASI_RIGHT_FD_SYNC = 0x0000000000000010n;
+const WASI_RIGHT_FD_TELL = 0x0000000000000020n;
+const WASI_RIGHT_FD_WRITE = 0x0000000000000040n;
+const WASI_RIGHT_FD_ADVISE = 0x0000000000000080n;
+const WASI_RIGHT_FD_ALLOCATE = 0x0000000000000100n;
+const WASI_RIGHT_PATH_CREATE_DIRECTORY = 0x0000000000000200n;
+const WASI_RIGHT_PATH_CREATE_FILE = 0x0000000000000400n;
+const WASI_RIGHT_PATH_LINK_SOURCE = 0x0000000000000800n;
+const WASI_RIGHT_PATH_LINK_TARGET = 0x0000000000001000n;
+const WASI_RIGHT_PATH_OPEN = 0x0000000000002000n;
+const WASI_RIGHT_FD_READDIR = 0x0000000000004000n;
+const WASI_RIGHT_PATH_READLINK = 0x0000000000008000n;
+const WASI_RIGHT_PATH_RENAME_SOURCE = 0x0000000000010000n;
+const WASI_RIGHT_PATH_RENAME_TARGET = 0x0000000000020000n;
+const WASI_RIGHT_PATH_FILESTAT_GET = 0x0000000000040000n;
+const WASI_RIGHT_PATH_FILESTAT_SET_SIZE = 0x0000000000080000n;
+const WASI_RIGHT_PATH_FILESTAT_SET_TIMES = 0x0000000000100000n;
+const WASI_RIGHT_FD_FILESTAT_GET = 0x0000000000200000n;
+const WASI_RIGHT_FD_FILESTAT_SET_SIZE = 0x0000000000400000n;
+const WASI_RIGHT_FD_FILESTAT_SET_TIMES = 0x0000000000800000n;
+const WASI_RIGHT_PATH_SYMLINK = 0x0000000001000000n;
+const WASI_RIGHT_PATH_REMOVE_DIRECTORY = 0x0000000002000000n;
+const WASI_RIGHT_PATH_UNLINK_FILE = 0x0000000004000000n;
+const WASI_RIGHT_POLL_FD_READWRITE = 0x0000000008000000n;
+const WASI_RIGHT_SOCK_SHUTDOWN = 0x0000000010000000n;
+
+const RIGHTS_ALL = WASI_RIGHT_FD_DATASYNC | WASI_RIGHT_FD_READ |
+  WASI_RIGHT_FD_SEEK | WASI_RIGHT_FD_FDSTAT_SET_FLAGS | WASI_RIGHT_FD_SYNC |
+  WASI_RIGHT_FD_TELL | WASI_RIGHT_FD_WRITE | WASI_RIGHT_FD_ADVISE |
+  WASI_RIGHT_FD_ALLOCATE | WASI_RIGHT_PATH_CREATE_DIRECTORY |
+  WASI_RIGHT_PATH_CREATE_FILE | WASI_RIGHT_PATH_LINK_SOURCE |
+  WASI_RIGHT_PATH_LINK_TARGET | WASI_RIGHT_PATH_OPEN | WASI_RIGHT_FD_READDIR |
+  WASI_RIGHT_PATH_READLINK | WASI_RIGHT_PATH_RENAME_SOURCE |
+  WASI_RIGHT_PATH_RENAME_TARGET | WASI_RIGHT_PATH_FILESTAT_GET |
+  WASI_RIGHT_PATH_FILESTAT_SET_SIZE | WASI_RIGHT_PATH_FILESTAT_SET_TIMES |
+  WASI_RIGHT_FD_FILESTAT_GET | WASI_RIGHT_FD_FILESTAT_SET_TIMES |
+  WASI_RIGHT_FD_FILESTAT_SET_SIZE | WASI_RIGHT_PATH_SYMLINK |
+  WASI_RIGHT_PATH_UNLINK_FILE | WASI_RIGHT_PATH_REMOVE_DIRECTORY |
+  WASI_RIGHT_POLL_FD_READWRITE | WASI_RIGHT_SOCK_SHUTDOWN;
+
+const RIGHTS_BLOCK_DEVICE_BASE = RIGHTS_ALL;
+const RIGHTS_BLOCK_DEVICE_INHERITING = RIGHTS_ALL;
+
+const RIGHTS_CHARACTER_DEVICE_BASE = RIGHTS_ALL;
+const RIGHTS_CHARACTER_DEVICE_INHERITING = RIGHTS_ALL;
+
+const RIGHTS_REGULAR_FILE_BASE = WASI_RIGHT_FD_DATASYNC | WASI_RIGHT_FD_READ |
+  WASI_RIGHT_FD_SEEK | WASI_RIGHT_FD_FDSTAT_SET_FLAGS | WASI_RIGHT_FD_SYNC |
+  WASI_RIGHT_FD_TELL | WASI_RIGHT_FD_WRITE | WASI_RIGHT_FD_ADVISE |
+  WASI_RIGHT_FD_ALLOCATE | WASI_RIGHT_FD_FILESTAT_GET |
+  WASI_RIGHT_FD_FILESTAT_SET_SIZE | WASI_RIGHT_FD_FILESTAT_SET_TIMES |
+  WASI_RIGHT_POLL_FD_READWRITE;
+const RIGHTS_REGULAR_FILE_INHERITING = 0n;
+
+const RIGHTS_DIRECTORY_BASE = WASI_RIGHT_FD_FDSTAT_SET_FLAGS |
+  WASI_RIGHT_FD_SYNC | WASI_RIGHT_FD_ADVISE | WASI_RIGHT_PATH_CREATE_DIRECTORY |
+  WASI_RIGHT_PATH_CREATE_FILE | WASI_RIGHT_PATH_LINK_SOURCE |
+  WASI_RIGHT_PATH_LINK_TARGET | WASI_RIGHT_PATH_OPEN | WASI_RIGHT_FD_READDIR |
+  WASI_RIGHT_PATH_READLINK | WASI_RIGHT_PATH_RENAME_SOURCE |
+  WASI_RIGHT_PATH_RENAME_TARGET | WASI_RIGHT_PATH_FILESTAT_GET |
+  WASI_RIGHT_PATH_FILESTAT_SET_SIZE | WASI_RIGHT_PATH_FILESTAT_SET_TIMES |
+  WASI_RIGHT_FD_FILESTAT_GET | WASI_RIGHT_FD_FILESTAT_SET_TIMES |
+  WASI_RIGHT_PATH_SYMLINK | WASI_RIGHT_PATH_UNLINK_FILE |
+  WASI_RIGHT_PATH_REMOVE_DIRECTORY | WASI_RIGHT_POLL_FD_READWRITE;
+const RIGHTS_DIRECTORY_INHERITING = RIGHTS_DIRECTORY_BASE |
+  RIGHTS_REGULAR_FILE_BASE;
+
+const RIGHTS_SOCKET_BASE = WASI_RIGHT_FD_READ | WASI_RIGHT_FD_FDSTAT_SET_FLAGS |
+  WASI_RIGHT_FD_WRITE | WASI_RIGHT_FD_FILESTAT_GET |
+  WASI_RIGHT_POLL_FD_READWRITE | WASI_RIGHT_SOCK_SHUTDOWN;
+const RIGHTS_SOCKET_INHERITING = RIGHTS_ALL;
+
+const RIGHTS_TTY_BASE = WASI_RIGHT_FD_READ | WASI_RIGHT_FD_FDSTAT_SET_FLAGS |
+  WASI_RIGHT_FD_WRITE | WASI_RIGHT_FD_FILESTAT_GET |
+  WASI_RIGHT_POLL_FD_READWRITE;
+const RIGHTS_TTY_INHERITING = 0n;
+
+const WASI_CLOCK_MONOTONIC = 0;
+const WASI_CLOCK_PROCESS_CPUTIME_ID = 1;
+const WASI_CLOCK_REALTIME = 2;
+const WASI_CLOCK_THREAD_CPUTIME_ID = 3;
+
+const WASI_EVENTTYPE_CLOCK = 0;
+const WASI_EVENTTYPE_FD_READ = 1;
+const WASI_EVENTTYPE_FD_WRITE = 2;
+
+const WASI_FILESTAT_SET_ATIM = 1 << 0;
+const WASI_FILESTAT_SET_ATIM_NOW = 1 << 1;
+const WASI_FILESTAT_SET_MTIM = 1 << 2;
+const WASI_FILESTAT_SET_MTIM_NOW = 1 << 3;
+
+const WASI_O_CREAT = 1 << 0;
+const WASI_O_DIRECTORY = 1 << 1;
+const WASI_O_EXCL = 1 << 2;
+const WASI_O_TRUNC = 1 << 3;
+
+const WASI_PREOPENTYPE_DIR = 0;
+
+const WASI_DIRCOOKIE_START = 0;
+
+const WASI_STDIN_FILENO = 0;
+const WASI_STDOUT_FILENO = 1;
+const WASI_STDERR_FILENO = 2;
+
+const WASI_WHENCE_CUR = 0;
+const WASI_WHENCE_END = 1;
+const WASI_WHENCE_SET = 2;
+
+// http://man7.org/linux/man-pages/man3/errno.3.html
+const ERROR_MAP = {
+  E2BIG: WASI_E2BIG,
+  EACCES: WASI_EACCES,
+  EADDRINUSE: WASI_EADDRINUSE,
+  EADDRNOTAVAIL: WASI_EADDRNOTAVAIL,
+  EAFNOSUPPORT: WASI_EAFNOSUPPORT,
+  EALREADY: WASI_EALREADY,
+  EAGAIN: WASI_EAGAIN,
+  // EBADE: WASI_EBADE,
+  EBADF: WASI_EBADF,
+  // EBADFD: WASI_EBADFD,
+  EBADMSG: WASI_EBADMSG,
+  // EBADR: WASI_EBADR,
+  // EBADRQC: WASI_EBADRQC,
+  // EBADSLT: WASI_EBADSLT,
+  EBUSY: WASI_EBUSY,
+  ECANCELED: WASI_ECANCELED,
+  ECHILD: WASI_ECHILD,
+  // ECHRNG: WASI_ECHRNG,
+  // ECOMM: WASI_ECOMM,
+  ECONNABORTED: WASI_ECONNABORTED,
+  ECONNREFUSED: WASI_ECONNREFUSED,
+  ECONNRESET: WASI_ECONNRESET,
+  EDEADLOCK: WASI_EDEADLK,
+  EDESTADDRREQ: WASI_EDESTADDRREQ,
+  EDOM: WASI_EDOM,
+  EDQUOT: WASI_EDQUOT,
+  EEXIST: WASI_EEXIST,
+  EFAULT: WASI_EFAULT,
+  EFBIG: WASI_EFBIG,
+  EHOSTDOWN: WASI_EHOSTUNREACH,
+  EHOSTUNREACH: WASI_EHOSTUNREACH,
+  // EHWPOISON: WASI_EHWPOISON,
+  EIDRM: WASI_EIDRM,
+  EILSEQ: WASI_EILSEQ,
+  EINPROGRESS: WASI_EINPROGRESS,
+  EINTR: WASI_EINTR,
+  EINVAL: WASI_EINVAL,
+  EIO: WASI_EIO,
+  EISCONN: WASI_EISCONN,
+  EISDIR: WASI_EISDIR,
+  // EISNAM: WASI_EISNAM,
+  // EKEYEXPIRED: WASI_EKEYEXPIRED,
+  // EKEYREJECTED: WASI_EKEYREJECTED,
+  // EKEYREVOKED: WASI_EKEYREVOKED,
+  // EL2HLT: WASI_EL2HLT,
+  // EL2NSYNC: WASI_EL2NSYNC,
+  // EL3HLT: WASI_EL3HLT,
+  // EL3RST: WASI_EL3RST,
+  // ELIBACC: WASI_ELIBACC,
+  // ELIBBAD: WASI_ELIBBAD,
+  // ELIBMAX: WASI_ELIBMAX,
+  // ELIBSCN: WASI_ELIBSCN,
+  // ELIBEXEC: WASI_ELIBEXEC,
+  // ELNRANGE: WASI_ELNRANGE,
+  ELOOP: WASI_ELOOP,
+  // EMEDIUMTYPE: WASI_EMEDIUMTYPE,
+  EMFILE: WASI_EMFILE,
+  EMLINK: WASI_EMLINK,
+  EMSGSIZE: WASI_EMSGSIZE,
+  EMULTIHOP: WASI_EMULTIHOP,
+  ENAMETOOLONG: WASI_ENAMETOOLONG,
+  ENETDOWN: WASI_ENETDOWN,
+  ENETRESET: WASI_ENETRESET,
+  ENETUNREACH: WASI_ENETUNREACH,
+  ENFILE: WASI_ENFILE,
+  // ENOANO: WASI_ENOANO,
+  ENOBUFS: WASI_ENOBUFS,
+  // ENODATA: WASI_ENODATA,
+  ENODEV: WASI_ENODEV,
+  ENOENT: WASI_ENOENT,
+  ENOEXEC: WASI_ENOEXEC,
+  // ENOKEY: WASI_ENOKEY,
+  ENOLCK: WASI_ENOLCK,
+  ENOLINK: WASI_ENOLINK,
+  // ENOMEDIUM: WASI_ENOMEDIUM,
+  ENOMEM: WASI_ENOMEM,
+  ENOMSG: WASI_ENOMSG,
+  // ENONET: WASI_ENONET,
+  // ENOPKG: WASI_ENOPKG,
+  ENOPROTOOPT: WASI_ENOPROTOOPT,
+  ENOSPC: WASI_ENOSPC,
+  // ENOSR: WASI_ENOSR,
+  // ENOSTR: WASI_ENOSTR,
+  ENOSYS: WASI_ENOSYS,
+  // ENOTBLK: WASI_ENOTBLK,
+  ENOTCONN: WASI_ENOTCONN,
+  ENOTDIR: WASI_ENOTDIR,
+  ENOTEMPTY: WASI_ENOTEMPTY,
+  ENOTRECOVERABLE: WASI_ENOTRECOVERABLE,
+  ENOTSOCK: WASI_ENOTSOCK,
+  ENOTTY: WASI_ENOTTY,
+  // ENOTUNIQ: WASI_ENOTUNIQ,
+  ENXIO: WASI_ENXIO,
+  EOVERFLOW: WASI_EOVERFLOW,
+  EOWNERDEAD: WASI_EOWNERDEAD,
+  EPERM: WASI_EPERM,
+  // EPFNOSUPPORT: WASI_EPFNOSUPPORT,
+  EPIPE: WASI_EPIPE,
+  EPROTO: WASI_EPROTO,
+  EPROTONOSUPPORT: WASI_EPROTONOSUPPORT,
+  EPROTOTYPE: WASI_EPROTOTYPE,
+  ERANGE: WASI_ERANGE,
+  // EREMCHG: WASI_EREMCHG,
+  // EREMOTE: WASI_EREMOTE,
+  // EREMOTEIO: WASI_EREMOTEIO,
+  // ERESTART: WASI_ERESTART,
+  // ERFKILL: WASI_ERFKILL,
+  EROFS: WASI_EROFS,
+  // ESHUTDOWN: WASI_ESHUTDOWN,
+  ESPIPE: WASI_ESPIPE,
+  // ESOCKTNOSUPPORT: WASI_ESOCKTNOSUPPORT,
+  ESRCH: WASI_ESRCH,
+  ESTALE: WASI_ESTALE,
+  // ESTRPIPE: WASI_ESTRPIPE,
+  // ETIME: WASI_ETIME,
+  ETIMEDOUT: WASI_ETIMEDOUT,
+  // ETOOMANYREFS: WASI_ETOOMANYREFS,
+  ETXTBSY: WASI_ETXTBSY,
+  // EUCLEAN: WASI_EUCLEAN,
+  // EUNATCH: WASI_EUNATCH,
+  // EUSERS: WASI_EUSERS,
+  EXDEV: WASI_EXDEV,
+  // EXFULL: WASI_EXFULL,
+};
+
+const SIGNAL_MAP = {
+  __proto__: null,
+  [WASI_SIGHUP]: 'SIGHUP',
+  [WASI_SIGINT]: 'SIGINT',
+  [WASI_SIGQUIT]: 'SIGQUIT',
+  [WASI_SIGILL]: 'SIGILL',
+  [WASI_SIGTRAP]: 'SIGTRAP',
+  [WASI_SIGABRT]: 'SIGABRT',
+  // [WASI_SIGIOT]: 'SIGIOT',
+  [WASI_SIGBUS]: 'SIGBUS',
+  [WASI_SIGFPE]: 'SIGFPE',
+  [WASI_SIGKILL]: 'SIGKILL',
+  [WASI_SIGUSR1]: 'SIGUSR1',
+  [WASI_SIGSEGV]: 'SIGSEGV',
+  [WASI_SIGUSR2]: 'SIGUSR2',
+  [WASI_SIGPIPE]: 'SIGPIPE',
+  [WASI_SIGALRM]: 'SIGALRM',
+  [WASI_SIGTERM]: 'SIGTERM',
+  [WASI_SIGCHLD]: 'SIGCHLD',
+  [WASI_SIGCONT]: 'SIGCONT',
+  [WASI_SIGSTOP]: 'SIGSTOP',
+  [WASI_SIGTSTP]: 'SIGTSTP',
+  [WASI_SIGTTIN]: 'SIGTTIN',
+  [WASI_SIGTTOU]: 'SIGTTOU',
+  [WASI_SIGURG]: 'SIGURG',
+  [WASI_SIGXCPU]: 'SIGXCPU',
+  [WASI_SIGXFSZ]: 'SIGXFSZ',
+  [WASI_SIGVTALRM]: 'SIGVTALRM',
+  // [WASI_SIGPROF]: 'SIGPROF',
+  // [WASI_SIGWINCH]: 'SIGWINCH',
+  // [WASI_SIGIO]: 'SIGIO',
+  // [WASI_SIGINFO]: 'SIGINFO',
+  // [WASI_SIGSYS]: 'SIGSYS',
+};
+
+const msToNs = (ms) => {
+  const msInt = Math.trunc(ms);
+  const decimal = BigInt(Math.round((ms - msInt) * 1000));
+  const ns = BigInt(msInt) * 1000n;
+  return ns + decimal;
+};
+
+const CPUTIME_START = msToNs(perfHooks.performance.timeOrigin);
+
+const now = (clockId) => {
+  switch (clockId) {
+    case WASI_CLOCK_MONOTONIC:
+      return process.hrtime.bigint();
+    case WASI_CLOCK_REALTIME:
+      return binding.realtime();
+    case WASI_CLOCK_PROCESS_CPUTIME_ID:
+    case WASI_CLOCK_THREAD_CPUTIME_ID:
+      return process.hrtime.bigint() - CPUTIME_START;
+    default:
+      return null;
+  }
+};
+
+const wrap = (f) => (...args) => {
+  try {
+    return f(...args);
+  } catch (e) {
+    if (typeof e === 'number') {
+      return e;
+    }
+    if (e.errno) {
+      return ERROR_MAP[e.code] || WASI_EINVAL;
+    }
+    throw e;
+  }
+};
+
+const translateFileAttributes = (fd, stats) => {
+  switch (true) {
+    case stats.isBlockDevice():
+      return {
+        filetype: WASI_FILETYPE_BLOCK_DEVICE,
+        rightsBase: RIGHTS_BLOCK_DEVICE_BASE,
+        rightsInheriting: RIGHTS_BLOCK_DEVICE_INHERITING,
+      };
+    case stats.isCharacterDevice(): {
+      const filetype = WASI_FILETYPE_CHARACTER_DEVICE;
+      if (fd !== undefined && isTTY(fd)) {
+        return {
+          filetype,
+          rightsBase: RIGHTS_TTY_BASE,
+          rightsInheriting: RIGHTS_TTY_INHERITING,
+        };
+      }
+      return {
+        filetype,
+        rightsBase: RIGHTS_CHARACTER_DEVICE_BASE,
+        rightsInheriting: RIGHTS_CHARACTER_DEVICE_INHERITING,
+      };
+    }
+    case stats.isDirectory():
+      return {
+        filetype: WASI_FILETYPE_DIRECTORY,
+        rightsBase: RIGHTS_DIRECTORY_BASE,
+        rightsInheriting: RIGHTS_DIRECTORY_INHERITING,
+      };
+    case stats.isFIFO():
+      return {
+        filetype: WASI_FILETYPE_SOCKET_STREAM,
+        rightsBase: RIGHTS_SOCKET_BASE,
+        rightsInheriting: RIGHTS_SOCKET_INHERITING,
+      };
+    case stats.isFile():
+      return {
+        filetype: WASI_FILETYPE_REGULAR_FILE,
+        rightsBase: RIGHTS_REGULAR_FILE_BASE,
+        rightsInheriting: RIGHTS_REGULAR_FILE_INHERITING,
+      };
+    case stats.isSocket():
+      return {
+        filetype: WASI_FILETYPE_SOCKET_STREAM,
+        rightsBase: RIGHTS_SOCKET_BASE,
+        rightsInheriting: RIGHTS_SOCKET_INHERITING,
+      };
+    case stats.isSymbolicLink():
+      return {
+        filetype: WASI_FILETYPE_SYMBOLIC_LINK,
+        rightsBase: 0n,
+        rightsInheriting: 0n,
+      };
+    default:
+      return {
+        filetype: WASI_FILETYPE_UNKNOWN,
+        rightsBase: 0n,
+        rightsInheriting: 0n,
+      };
+  }
+};
+
+const stat = (wasi, fd) => {
+  const entry = wasi.FD_MAP.get(fd);
+  if (!entry) {
+    throw WASI_EBADF;
+  }
+  if (entry.filetype === undefined) {
+    const stats = fs.fstatSync(entry.real);
+    const {
+      filetype, rightsBase, rightsInheriting,
+    } = translateFileAttributes(fd, stats);
+    entry.filetype = filetype;
+    if (entry.rights === undefined) {
+      entry.rights = {
+        base: rightsBase,
+        inheriting: rightsInheriting,
+      };
+    }
+  }
+  return entry;
+};
+
+class WASI {
+  constructor({ preopenDirectories = { '.': '.' }, env = {}, args = [] } = {}) {
+    this.memory = undefined;
+    this.view = undefined;
+
+    this.FD_MAP = new Map([
+      [WASI_STDIN_FILENO, {
+        real: 0,
+        filetype: undefined,
+        rights: undefined,
+        path: undefined,
+      }],
+      [WASI_STDOUT_FILENO, {
+        real: 1,
+        filetype: undefined,
+        rights: undefined,
+        path: undefined,
+      }],
+      [WASI_STDERR_FILENO, {
+        real: 2,
+        filetype: undefined,
+        rights: undefined,
+        path: undefined,
+      }],
+    ]);
+
+    for (const [k, v] of Object.entries(preopenDirectories)) {
+      const real = fs.openSync(v);
+      const newfd = [...this.FD_MAP.keys()].reverse()[0] + 1;
+      this.FD_MAP.set(newfd, {
+        real,
+        filetype: WASI_FILETYPE_DIRECTORY,
+        rights: {
+          base: RIGHTS_DIRECTORY_BASE,
+          inheriting: RIGHTS_DIRECTORY_INHERITING,
+        },
+        fakePath: k,
+        path: v,
+      });
+    }
+
+    const getiovs = (iovs, iovsLen) => {
+      // iovs* -> [iov, iov, ...]
+      // __wasi_ciovec_t {
+      //   void* buf,
+      //   size_t buf_len,
+      // }
+
+      this.refreshMemory();
+
+      const buffers = Array.from({ length: iovsLen }, (_, i) => {
+        const ptr = iovs + (i * 8);
+        const bufPtr = this.view.getUint32(ptr, true);
+        const bufLen = this.view.getUint32(ptr + 4, true);
+        return new Uint8Array(this.memory.buffer, bufPtr, bufLen);
+      });
+
+      return buffers;
+    };
+
+    const CHECK_FD = (fd, rights) => {
+      const stats = stat(this, fd);
+      if (rights !== 0 && (stats.rights.base & rights) === 0) {
+        throw WASI_EPERM;
+      }
+      return stats;
+    };
+
+    this.exports = {
+      args_get: (argv, argvBuf) => {
+        this.refreshMemory();
+        let coffset = argv;
+        let offset = argvBuf;
+        args.forEach((a) => {
+          this.view.setUint32(coffset, offset, true);
+          coffset += 4;
+          offset += Buffer.from(this.memory.buffer).write(`${a}\0`, offset);
+        });
+        return WASI_ESUCCESS;
+      },
+      args_sizes_get: (argc, argvBufSize) => {
+        this.refreshMemory();
+        this.view.setUint32(argc, args.length, true);
+        const size = args.reduce((acc, a) => acc + Buffer.byteLength(a) + 1, 0);
+        this.view.setUint32(argvBufSize, size, true);
+        return WASI_ESUCCESS;
+      },
+      environ_get: (environ, environBuf) => {
+        this.refreshMemory();
+        let coffset = environ;
+        let offset = environBuf;
+        const cache = Buffer.from(this.memory.buffer);
+        Object.entries(env)
+          .forEach(([key, value]) => {
+            this.view.setUint32(coffset, offset, true);
+            coffset += 4;
+            offset += cache.write(`${key}=${value}\0`, offset);
+          });
+        return WASI_ESUCCESS;
+      },
+      environ_sizes_get: (environCount, environBufSize) => {
+        this.refreshMemory();
+        const envProcessed = Object.entries(env)
+          .map(([key, value]) => `${key}=${value}\0`);
+        const size = envProcessed.reduce((acc, e) =>
+          acc + Buffer.byteLength(e), 0);
+        this.view.setUint32(environCount, envProcessed.length, true);
+        this.view.setUint32(environBufSize, size, true);
+        return WASI_ESUCCESS;
+      },
+      clock_res_get: (clockId, resolution) => {
+        this.view.setBigUint64(resolution, 0n);
+        return WASI_ESUCCESS;
+      },
+      clock_time_get: (clockId, precision, time) => {
+        const n = now(clockId);
+        if (n === null) {
+          return WASI_EINVAL;
+        }
+        this.view.setBigUint64(time, n, true);
+        return WASI_ESUCCESS;
+      },
+      fd_advise: wrap((fd, offset, len, advice) => {
+        CHECK_FD(fd, WASI_RIGHT_FD_ADVISE);
+        return WASI_ENOSYS;
+      }),
+      fd_allocate: wrap((fd, offset, len) => {
+        CHECK_FD(fd, WASI_RIGHT_FD_ALLOCATE);
+        return WASI_ENOSYS;
+      }),
+      fd_close: wrap((fd) => {
+        const stats = CHECK_FD(fd, 0);
+        fs.closeSync(stats.real);
+        this.FD_MAP.delete(fd);
+        return WASI_ESUCCESS;
+      }),
+      fd_datasync: (fd) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_FD_DATASYNC);
+        fs.fdatasyncSync(stats.real);
+        return WASI_ESUCCESS;
+      },
+      fd_fdstat_get: wrap((fd, bufPtr) => {
+        const stats = CHECK_FD(fd, 0);
+        this.refreshMemory();
+        this.view.setUint8(bufPtr, stats.filetype); // FILETYPE u8
+        this.view.setUint16(bufPtr + 2, 0, true); // FDFLAG u16
+        this.view.setUint16(bufPtr + 4, 0, true); // FDFLAG u16
+        this.view.setBigUint64(bufPtr + 8, stats.rights.base, true); // u64
+        this.view.setBigUint64(
+          bufPtr + 8 + 8, stats.rights.inheriting, true,
+        ); // u64
+        return WASI_ESUCCESS;
+      }),
+      fd_fdstat_set_flags: wrap((fd, flags) => {
+        CHECK_FD(fd, WASI_RIGHT_FD_FDSTAT_SET_FLAGS);
+        return WASI_ENOSYS;
+      }),
+      fd_fdstat_set_rights: wrap((fd, fsRightsBase, fsRightsInheriting) => {
+        const stats = CHECK_FD(fd, 0);
+        const nrb = stats.rights.base | fsRightsBase;
+        if (nrb > stats.rights.base) {
+          return WASI_EPERM;
+        }
+        const nri = stats.rights.inheriting | fsRightsInheriting;
+        if (nri > stats.rights.inheriting) {
+          return WASI_EPERM;
+        }
+        stats.rights.base = nrb;
+        stats.rights.inheriting = nri;
+        return WASI_ESUCCESS;
+      }),
+      fd_filestat_get: wrap((fd, bufPtr) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_FD_FILESTAT_GET);
+        const rstats = fs.fstatSync(stats.real);
+        this.refreshMemory();
+        this.view.setBigUint64(bufPtr, BigInt(rstats.dev), true);
+        bufPtr += 8;
+        this.view.setBigUint64(bufPtr, BigInt(rstats.ino), true);
+        bufPtr += 8;
+        this.view.setUint8(bufPtr, stats.filetype);
+        bufPtr += 4;
+        this.view.setUint32(bufPtr, Number(rstats.nlink), true);
+        bufPtr += 4;
+        this.view.setBigUint64(bufPtr, BigInt(rstats.size), true);
+        bufPtr += 8;
+        this.view.setBigUint64(bufPtr, msToNs(rstats.atimeMs), true);
+        bufPtr += 8;
+        this.view.setBigUint64(bufPtr, msToNs(rstats.mtimeMs), true);
+        bufPtr += 8;
+        this.view.setBigUint64(bufPtr, msToNs(rstats.ctimeMs), true);
+        bufPtr += 8;
+        return WASI_ESUCCESS;
+      }),
+      fd_filestat_set_size: wrap((fd, stSize) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_FD_FILESTAT_SET_SIZE);
+        fs.ftruncate(stats.real, Number(stSize));
+        return WASI_ESUCCESS;
+      }),
+      fd_filestat_set_times: wrap((fd, stAtim, stMtim, fstflags) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_FD_FILESTAT_SET_TIMES);
+        const n = now(WASI_CLOCK_REALTIME);
+        const atimNow = (fstflags & WASI_FILESTAT_SET_ATIM_NOW) ===
+          WASI_FILESTAT_SET_ATIM_NOW;
+        const mtimNow = (fstflags & WASI_FILESTAT_SET_MTIM_NOW) ===
+          WASI_FILESTAT_SET_MTIM_NOW;
+        fs.futimesSync(
+          stats.real,
+          atimNow ? n : stAtim,
+          mtimNow ? n : stMtim,
+        );
+        return WASI_ESUCCESS;
+      }),
+      fd_prestat_get: wrap((fd, bufPtr) => {
+        const stats = CHECK_FD(fd, 0);
+        if (!stats.path) {
+          return WASI_EINVAL;
+        }
+        this.refreshMemory();
+        this.view.setUint8(bufPtr, WASI_PREOPENTYPE_DIR);
+        this.view.setUint32(
+          bufPtr + 4, Buffer.byteLength(stats.fakePath), true,
+        );
+        return WASI_ESUCCESS;
+      }),
+      fd_prestat_dir_name: wrap((fd, pathPtr, pathLen) => {
+        const stats = CHECK_FD(fd, 0);
+        if (!stats.path) {
+          return WASI_EINVAL;
+        }
+        this.refreshMemory();
+        Buffer.from(this.memory.buffer)
+          .write(stats.fakePath, pathPtr, pathLen, 'utf8');
+        return WASI_ESUCCESS;
+      }),
+      fd_pwrite: wrap((fd, iovs, iovsLen, offset, nwritten) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_FD_WRITE | WASI_RIGHT_FD_SEEK);
+        let written = 0;
+        getiovs(iovs, iovsLen)
+          .forEach((iov) => {
+            let w = 0;
+            while (w < iov.byteLength) {
+              w += fs.writeSync(
+                stats.real, iov, w, iov.byteLength - w, offset + written + w,
+              );
+            }
+            written += w;
+          });
+        this.view.setUint32(nwritten, written, true);
+        return WASI_ESUCCESS;
+      }),
+      fd_write: wrap((fd, iovs, iovsLen, nwritten) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_FD_WRITE);
+        let written = 0;
+        getiovs(iovs, iovsLen)
+          .forEach((iov) => {
+            let w = 0;
+            while (w < iov.byteLength) {
+              w += fs.writeSync(stats.real, iov, w, iov.byteLength - w);
+            }
+            written += w;
+          });
+        this.view.setUint32(nwritten, written, true);
+        return WASI_ESUCCESS;
+      }),
+      fd_pread: wrap((fd, iovs, iovsLen, offset, nread) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_FD_READ | WASI_RIGHT_FD_SEEK);
+        let read = 0;
+        getiovs(iovs, iovsLen)
+          .forEach((iov) => {
+            let r = 0;
+            while (r < iov.byteLength) {
+              r += fs.readSync(
+                stats.real, iov, r, iov.byteLength - r, offset + read + r,
+              );
+            }
+            read += r;
+          });
+        this.view.setUint32(nread, read, true);
+        return WASI_ESUCCESS;
+      }),
+      fd_read: wrap((fd, iovs, iovsLen, nread) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_FD_READ);
+        let read = 0;
+        outer:
+        for (const iov of getiovs(iovs, iovsLen)) {
+          let r = 0;
+          while (r < iov.byteLength) {
+            const rr = fs.readSync(stats.real, iov, r, iov.byteLength - r);
+            r += rr;
+            read += rr;
+            if (rr === 0) {
+              break outer;
+            }
+          }
+        }
+        this.view.setUint32(nread, read, true);
+        return WASI_ESUCCESS;
+      }),
+      fd_readdir: wrap((fd, bufPtr, bufLen, cookie, bufusedPtr) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_FD_READDIR);
+        this.refreshMemory();
+        const entries = fs.readdirSync(stats.path, { withFileTypes: true });
+        const startPtr = bufPtr;
+        const cache = Buffer.from(this.memory.buffer);
+        for (let i = Number(cookie); i < entries.length; i += 1) {
+          const entry = entries[i];
+          this.view.setBigUint64(bufPtr, BigInt(i + 1), true);
+          bufPtr += 8;
+          const rstats = fs.statSync(path.resolve(stats.path, entry.name));
+          this.view.setBigUint64(bufPtr, BigInt(rstats.ino), true);
+          bufPtr += 8;
+          this.view.setUint32(bufPtr, Buffer.byteLength(entry.name), true);
+          bufPtr += 4;
+          let filetype;
+          switch (true) {
+            case rstats.isBlockDevice():
+              filetype = WASI_FILETYPE_BLOCK_DEVICE;
+              break;
+            case rstats.isCharacterDevice():
+              filetype = WASI_FILETYPE_CHARACTER_DEVICE;
+              break;
+            case rstats.isDirectory():
+              filetype = WASI_FILETYPE_DIRECTORY;
+              break;
+            case rstats.isFIFO():
+              filetype = WASI_FILETYPE_SOCKET_STREAM;
+              break;
+            case rstats.isFile():
+              filetype = WASI_FILETYPE_REGULAR_FILE;
+              break;
+            case rstats.isSocket():
+              filetype = WASI_FILETYPE_SOCKET_STREAM;
+              break;
+            case rstats.isSymbolicLink():
+              filetype = WASI_FILETYPE_SYMBOLIC_LINK;
+              break;
+            default:
+              filetype = WASI_FILETYPE_UNKNOWN;
+              break;
+          }
+          this.view.setUint8(bufPtr, filetype);
+          bufPtr += 1;
+          bufPtr += 3; // padding
+          bufPtr += cache.write(entry.name, bufPtr, bufLen - bufPtr);
+          bufPtr += (8 % bufPtr); // padding
+        }
+        const bufused = bufPtr - startPtr;
+        this.view.setUint32(bufusedPtr, bufused, true);
+        return WASI_ESUCCESS;
+      }),
+      fd_renumber: wrap((from, to) => {
+        CHECK_FD(from, 0);
+        CHECK_FD(to, 0);
+        fs.closeSync(this.FD_MAP.get(to).real);
+        this.FD_MAP.set(to, this.FD_MAP.get(from));
+        this.FD_MAP.delete(from);
+        return WASI_ESUCCESS;
+      }),
+      fd_seek: wrap((fd, offset, whence, newOffsetPtr) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_FD_SEEK);
+        const newOffset = binding.seek(stats.real, offset, {
+          [WASI_WHENCE_CUR]: binding.SEEK_CUR,
+          [WASI_WHENCE_END]: binding.SEEK_END,
+          [WASI_WHENCE_SET]: binding.SEEK_SET,
+        }[whence]);
+        if (typeof newOffset === 'number') { // errno
+          throw newOffset;
+        }
+        this.refreshMemory();
+        this.view.setBigUint64(newOffsetPtr, newOffset, true);
+        return WASI_ESUCCESS;
+      }),
+      fd_tell: wrap((fd, offsetPtr) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_FD_TELL);
+        const currentOffset = binding.seek(stats.real, 0n, binding.SEEK_CUR);
+        if (typeof currentOffset === 'number') { // errno
+          throw currentOffset;
+        }
+        this.refreshMemory();
+        this.view.setBigUint64(offsetPtr, currentOffset, true);
+        return WASI_ESUCCESS;
+      }),
+      fd_sync: wrap((fd) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_FD_SYNC);
+        fs.fsyncSync(stats.real);
+        return WASI_ESUCCESS;
+      }),
+      path_create_directory: wrap((fd, pathPtr, pathLen) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_PATH_CREATE_DIRECTORY);
+        if (!stats.path) {
+          return WASI_EINVAL;
+        }
+        this.refreshMemory();
+        const p = Buffer.from(this.memory.buffer, pathPtr, pathLen).toString();
+        // FIXME: figure out using mkdirat()
+        fs.mkdirSync(path.resolve(stats.path, p));
+        return WASI_ESUCCESS;
+      }),
+      path_filestat_get: wrap((fd, flags, pathPtr, pathLen, bufPtr) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_PATH_FILESTAT_GET);
+        if (!stats.path) {
+          return WASI_EINVAL;
+        }
+        this.refreshMemory();
+        const p = Buffer.from(this.memory.buffer, pathPtr, pathLen).toString();
+        const rstats = fs.statSync(path.resolve(stats.path, p));
+        this.view.setBigUint64(bufPtr, BigInt(rstats.dev), true);
+        bufPtr += 8;
+        this.view.setBigUint64(bufPtr, BigInt(rstats.ino), true);
+        bufPtr += 8;
+        this.view.setUint8(bufPtr,
+                           translateFileAttributes(undefined, rstats).filetype);
+        bufPtr += 4;
+        this.view.setUint32(bufPtr, Number(rstats.nlink), true);
+        bufPtr += 4;
+        this.view.setBigUint64(bufPtr, BigInt(rstats.size), true);
+        bufPtr += 8;
+        this.view.setBigUint64(bufPtr, msToNs(rstats.atimeMs), true);
+        bufPtr += 8;
+        this.view.setBigUint64(bufPtr, msToNs(rstats.mtimeMs), true);
+        bufPtr += 8;
+        this.view.setBigUint64(bufPtr, msToNs(rstats.ctimeMs), true);
+        bufPtr += 8;
+        return WASI_ESUCCESS;
+      }),
+      path_filestat_set_times:
+        wrap((fd, fstflags, pathPtr, pathLen, stAtim, stMtim) => {
+          const stats = CHECK_FD(fd, WASI_RIGHT_PATH_FILESTAT_SET_TIMES);
+          if (!stats.path) {
+            return WASI_EINVAL;
+          }
+          this.refreshMemory();
+          const n = now(WASI_CLOCK_REALTIME);
+          const atimNow = (fstflags & WASI_FILESTAT_SET_ATIM_NOW) ===
+            WASI_FILESTAT_SET_ATIM_NOW;
+          const mtimNow = (fstflags & WASI_FILESTAT_SET_MTIM_NOW) ===
+            WASI_FILESTAT_SET_MTIM_NOW;
+          const p = Buffer.from(this.memory.buffer, pathPtr, pathLen)
+            .toString();
+          fs.utimesSync(
+            path.resolve(stats.path, p),
+            atimNow ? n : stAtim,
+            mtimNow ? n : stMtim,
+          );
+          return WASI_ESUCCESS;
+        }),
+      path_link: wrap(
+        (oldFd, oldFlags, oldPath, oldPathLen, newFd, newPath, newPathLen) => {
+          const ostats = CHECK_FD(oldFd, WASI_RIGHT_PATH_LINK_SOURCE);
+          const nstats = CHECK_FD(newFd, WASI_RIGHT_PATH_LINK_TARGET);
+          if (!ostats.path || !nstats.path) {
+            return WASI_EINVAL;
+          }
+          this.refreshMemory();
+          const op = Buffer.from(
+            this.memory.buffer, oldPath, oldPathLen,
+          ).toString();
+          const np = Buffer.from(
+            this.memory.buffer, newPath, newPathLen,
+          ).toString();
+          fs.linkSync(
+            path.resolve(ostats.path, op), path.resolve(nstats.path, np),
+          );
+          return WASI_ESUCCESS;
+        },
+      ),
+      path_open: wrap((dirfd, dirflags, pathPtr, pathLen, oflags,
+                       fsRightsBase, fsRightsInheriting, fsFlags, fd) => {
+        const stats = CHECK_FD(dirfd, WASI_RIGHT_PATH_OPEN);
+
+        const read = (fsRightsBase &
+            (WASI_RIGHT_FD_READ | WASI_RIGHT_FD_READDIR)) !== 0n;
+        const write = (fsRightsBase &
+          (WASI_RIGHT_FD_DATASYNC |
+            WASI_RIGHT_FD_WRITE |
+            WASI_RIGHT_FD_ALLOCATE |
+            WASI_RIGHT_FD_FILESTAT_SET_SIZE)) !== 0n;
+
+        let noflags;
+        if (write && read) {
+          noflags = fs.constants.O_RDWR;
+        } else if (read) {
+          noflags = fs.constants.O_RDONLY;
+        } else if (write) {
+          noflags = fs.constants.O_WRONLY;
+        }
+
+        let neededBase = WASI_RIGHT_PATH_OPEN;
+        let neededInheriting = fsRightsBase | fsRightsInheriting;
+
+        if ((oflags & WASI_O_CREAT) !== 0) {
+          noflags |= fs.constants.O_CREAT;
+          neededBase |= WASI_RIGHT_PATH_CREATE_FILE;
+        }
+        if ((oflags & WASI_O_DIRECTORY) !== 0) {
+          noflags |= fs.constants.O_DIRECTORY;
+        }
+        if ((oflags & WASI_O_EXCL) !== 0) {
+          noflags |= fs.constants.O_EXCL;
+        }
+        if ((oflags & WASI_O_TRUNC) !== 0) {
+          noflags |= fs.constants.O_TRUNC;
+          neededBase |= WASI_RIGHT_PATH_FILESTAT_SET_SIZE;
+        }
+
+        // Convert file descriptor flags.
+        if ((fsFlags & WASI_FDFLAG_APPEND) !== 0) {
+          noflags |= fs.constants.O_APPEND;
+        }
+        if ((fsFlags & WASI_FDFLAG_DSYNC) !== 0) {
+          if (fs.constants.O_DSYNC) {
+            noflags |= fs.constants.O_DSYNC;
+          } else {
+            noflags |= fs.constants.O_SYNC;
+          }
+          neededInheriting |= WASI_RIGHT_FD_DATASYNC;
+        }
+        if ((fsFlags & WASI_FDFLAG_NONBLOCK) !== 0) {
+          noflags |= fs.constants.O_NONBLOCK;
+        }
+        if ((fsFlags & WASI_FDFLAG_RSYNC) !== 0) {
+          if (fs.constants.O_RSYNC) {
+            noflags |= fs.constants.O_RSYNC;
+          } else {
+            noflags |= fs.constants.O_SYNC;
+          }
+          neededInheriting |= WASI_RIGHT_FD_SYNC;
+        }
+        if ((fsFlags & WASI_FDFLAG_SYNC) !== 0) {
+          noflags |= fs.constants.O_SYNC;
+          neededInheriting |= WASI_RIGHT_FD_SYNC;
+        }
+        if (write && (noflags &
+            (fs.constants.O_APPEND | fs.constants.O_TRUNC)) === 0) {
+          neededInheriting |= WASI_RIGHT_FD_SEEK;
+        }
+
+        this.refreshMemory();
+        const p = Buffer.from(this.memory.buffer, pathPtr, pathLen).toString();
+        const fullUnresolved = path.resolve(stats.path, p);
+        if (path.relative(stats.path, fullUnresolved).startsWith('..')) {
+          return WASI_ENOTCAPABLE;
+        }
+        let full;
+        try {
+          full = fs.realpathSync(fullUnresolved);
+          if (path.relative(stats.path, full).startsWith('..')) {
+            return WASI_ENOTCAPABLE;
+          }
+        } catch (e) {
+          if (e.code === 'ENOENT') {
+            full = fullUnresolved;
+          } else {
+            throw e;
+          }
+        }
+        const realfd = fs.openSync(full, noflags);
+
+        const newfd = [...this.FD_MAP.keys()].reverse()[0] + 1;
+        this.FD_MAP.set(newfd, {
+          real: realfd,
+          filetype: undefined,
+          rights: {
+            base: neededBase,
+            inheriting: neededInheriting,
+          },
+          path: full,
+        });
+        stat(this, newfd);
+        this.view.setUint32(fd, newfd, true);
+
+        return WASI_ESUCCESS;
+      }),
+      path_readlink: wrap((fd, pathPtr, pathLen, buf, bufLen, bufused) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_PATH_READLINK);
+        if (!stats.path) {
+          return WASI_EINVAL;
+        }
+        this.refreshMemory();
+        const p = Buffer.from(this.memory.buffer, pathPtr, pathLen).toString();
+        const full = path.resolve(stats.path, p);
+        const r = fs.readlinkSync(full);
+        const used = Buffer.from(this.memory.buffer).write(r, buf, bufLen);
+        this.view.setUint32(bufused, used, true);
+        return WASI_ESUCCESS;
+      }),
+      path_remove_directory: wrap((fd, pathPtr, pathLen) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_PATH_REMOVE_DIRECTORY);
+        if (!stats.path) {
+          return WASI_EINVAL;
+        }
+        this.refreshMemory();
+        const p = Buffer.from(this.memory.buffer, pathPtr, pathLen).toString();
+        fs.rmdirSync(path.resolve(stats.path, p));
+        return WASI_ESUCCESS;
+      }),
+      path_rename: wrap(
+        (oldFd, oldPath, oldPathLen, newFd, newPath, newPathLen) => {
+          const ostats = CHECK_FD(oldFd, WASI_RIGHT_PATH_RENAME_SOURCE);
+          const nstats = CHECK_FD(newFd, WASI_RIGHT_PATH_RENAME_TARGET);
+          if (!ostats.path || !nstats.path) {
+            return WASI_EINVAL;
+          }
+          this.refreshMemory();
+          const op = Buffer.from(
+            this.memory.buffer, oldPath, oldPathLen,
+          ).toString();
+          const np = Buffer.from(
+            this.memory.buffer, newPath, newPathLen,
+          ).toString();
+          fs.renameSync(
+            path.resolve(ostats.path, op), path.resolve(nstats.path, np),
+          );
+          return WASI_ESUCCESS;
+        },
+      ),
+      path_symlink: wrap((oldPath, oldPathLen, fd, newPath, newPathLen) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_PATH_SYMLINK);
+        if (!stats.path) {
+          return WASI_EINVAL;
+        }
+        this.refreshMemory();
+        const op = Buffer.from(
+          this.memory.buffer, oldPath, oldPathLen,
+        ).toString();
+        const np = Buffer.from(
+          this.memory.buffer, newPath, newPathLen,
+        ).toString();
+        fs.symlinkSync(op, path.resolve(stats.path, np));
+        return WASI_ESUCCESS;
+      }),
+      path_unlink_file: wrap((fd, pathPtr, pathLen) => {
+        const stats = CHECK_FD(fd, WASI_RIGHT_PATH_UNLINK_FILE);
+        if (!stats.path) {
+          return WASI_EINVAL;
+        }
+        this.refreshMemory();
+        const p = Buffer.from(this.memory.buffer, pathPtr, pathLen).toString();
+        fs.unlinkSync(path.resolve(stats.path, p));
+        return WASI_ESUCCESS;
+      }),
+      poll_oneoff: (sin, sout, nsubscriptions, nevents) => {
+        let eventc = 0;
+        let waitEnd = 0;
+        this.refreshMemory();
+        for (let i = 0; i < nsubscriptions; i += 1) {
+          const userdata = this.view.getBigUint64(sin, true);
+          sin += 8;
+          const type = this.view.getUint8(sin);
+          sin += 1;
+          switch (type) {
+            case WASI_EVENTTYPE_CLOCK: {
+              sin += 7; // padding
+              const identifier = this.view.getBigUint64(sin, true);
+              sin += 8;
+              const clockid = this.view.getUint32(sin, true);
+              sin += 4;
+              sin += 4; // padding
+              const timestamp = this.view.getBigUint64(sin, true);
+              sin += 8;
+              const precision = this.view.getBigUint64(sin, true);
+              sin += 8;
+              const subclockflags = this.view.getUint16(sin, true);
+              sin += 2;
+              sin += 6; // padding
+
+              const absolute = subclockflags === 1;
+
+              let e = WASI_ESUCCESS;
+              const n = now(clockid);
+              if (n === null) {
+                e = WASI_EINVAL;
+              } else {
+                const end = absolute ? timestamp : n + timestamp;
+                waitEnd = end > waitEnd ? end : waitEnd;
+              }
+
+              this.view.setBigUint64(sout, userdata, true);
+              sout += 8;
+              this.view.setUint16(sout, e, true); // error
+              sout += 2; // pad offset 2
+              this.view.setUint8(sout, WASI_EVENTTYPE_CLOCK);
+              sout += 1; // pad offset 3
+              sout += 5; // padding to 8
+
+              eventc += 1;
+
+              break;
+            }
+            case WASI_EVENTTYPE_FD_READ:
+            case WASI_EVENTTYPE_FD_WRITE: {
+              sin += 3; // padding
+              const fd = this.view.getUint32(sin, true);
+              sin += 4;
+
+              this.view.setBigUint64(sout, userdata, true);
+              sout += 8;
+              this.view.setUint16(sout, WASI_ENOSYS, true); // error
+              sout += 2; // pad offset 2
+              this.view.setUint8(sout, type);
+              sout += 1; // pad offset 3
+              sout += 5; // padding to 8
+
+              eventc += 1;
+
+              break;
+            }
+            default:
+              return WASI_EINVAL;
+          }
+        }
+
+        this.view.setUint32(nevents, eventc, true);
+
+        while (process.hrtime.bigint() < waitEnd) {
+          // nothing
+          // FIXME: use some sort of sleep instead of looping
+        }
+
+        return WASI_ESUCCESS;
+      },
+      proc_exit: (rval) => {
+        process.exit(rval);
+        return WASI_ESUCCESS;
+      },
+      proc_raise: (sig) => {
+        if (!(sig in SIGNAL_MAP)) {
+          return WASI_EINVAL;
+        }
+        process.kill(process.pid, SIGNAL_MAP[sig]);
+        return WASI_ESUCCESS;
+      },
+      random_get: (bufPtr, bufLen) => {
+        this.refreshMemory();
+        crypto.randomFillSync(
+          new Uint8Array(this.memory.buffer), bufPtr, bufLen,
+        );
+        return WASI_ESUCCESS;
+      },
+      sched_yield() {
+        binding.schedYield();
+        return WASI_ESUCCESS;
+      },
+      sock_recv() {
+        return WASI_ENOSYS;
+      },
+      sock_send() {
+        return WASI_ENOSYS;
+      },
+      sock_shutdown() {
+        return WASI_ENOSYS;
+      },
+    };
+  }
+
+  refreshMemory() {
+    if (this.view === undefined || this.view.byteLength === 0) {
+      this.view = new DataView(this.memory.buffer);
+    }
+  }
+
+  setMemory(m) {
+    this.memory = m;
+  }
+}
+
+module.exports = WASI;
diff --git a/node.gyp b/node.gyp
index 9a5556c2eff40d..7bb300eeaeb1e6 100644
--- a/node.gyp
+++ b/node.gyp
@@ -196,6 +196,7 @@
       'lib/internal/validators.js',
       'lib/internal/stream_base_commons.js',
       'lib/internal/vm/source_text_module.js',
+      'lib/internal/wasi.js',
       'lib/internal/worker.js',
       'lib/internal/worker/io.js',
       'lib/internal/streams/lazy_transform.js',
@@ -556,6 +557,7 @@
         'src/node_url.cc',
         'src/node_util.cc',
         'src/node_v8.cc',
+        'src/node_wasi.cc',
         'src/node_watchdog.cc',
         'src/node_worker.cc',
         'src/node_zlib.cc',
diff --git a/src/node_binding.cc b/src/node_binding.cc
index 99c2406036e187..0dfe8bff355df4 100644
--- a/src/node_binding.cc
+++ b/src/node_binding.cc
@@ -84,6 +84,7 @@
   V(util)                                                                      \
   V(uv)                                                                        \
   V(v8)                                                                        \
+  V(wasi)                                                                      \
   V(worker)                                                                    \
   V(zlib)
 
diff --git a/src/node_binding.h b/src/node_binding.h
index dd94fab36a0e8f..d4f655a5d57f03 100644
--- a/src/node_binding.h
+++ b/src/node_binding.h
@@ -49,6 +49,18 @@ namespace node {
 #define NODE_MODULE_CONTEXT_AWARE_INTERNAL(modname, regfunc)                   \
   NODE_MODULE_CONTEXT_AWARE_CPP(modname, regfunc, nullptr, NM_F_INTERNAL)
 
+#define NODE_MODULE_CONTEXT_AWARE_INTERNAL_NAPI(modname, regfunc)              \
+  static napi_module _module = {                                               \
+    NAPI_MODULE_VERSION,                                                       \
+    NM_F_INTERNAL,                                                             \
+    __FILE__,                                                                  \
+    regfunc,                                                                   \
+    #modname,                                                                  \
+    nullptr,                                                                   \
+    {0},                                                                       \
+  };                                                                           \
+  void _register_##modname() { napi_module_register(&_module); }               \
+
 // Globals per process
 // This is set by node::Init() which is used by embedders
 extern bool node_is_initialized;
diff --git a/src/node_constants.cc b/src/node_constants.cc
index 7c9e4ce276112b..5183bb9ac13571 100644
--- a/src/node_constants.cc
+++ b/src/node_constants.cc
@@ -1260,6 +1260,18 @@ void DefineSystemConstants(Local<Object> target) {
   NODE_DEFINE_CONSTANT(target, COPYFILE_FICLONE_FORCE);
 # undef COPYFILE_FICLONE_FORCE
 #endif
+
+#ifdef SEEK_SET
+  NODE_DEFINE_CONSTANT(target, SEEK_SET);
+#endif
+
+#ifdef SEEK_CUR
+  NODE_DEFINE_CONSTANT(target, SEEK_CUR);
+#endif
+
+#ifdef SEEK_END
+  NODE_DEFINE_CONSTANT(target, SEEK_END);
+#endif
 }
 
 void DefineDLOpenConstants(Local<Object> target) {
diff --git a/src/node_options.cc b/src/node_options.cc
index 2b177806683a63..9a3e2ac8ae06e6 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -305,9 +305,14 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             &EnvironmentOptions::experimental_modules,
             kAllowedInEnvironment);
   AddOption("--experimental-wasm-modules",
-            "experimental ES Module support for webassembly modules",
+            "experimental ES Module support for WebAssembly modules",
             &EnvironmentOptions::experimental_wasm_modules,
             kAllowedInEnvironment);
+  AddOption("--experimental-wasi-modules",
+            "experimental WASI support for WebAssembly modules",
+            &EnvironmentOptions::experimental_wasi_modules,
+            kAllowedInEnvironment);
+  Implies("--experimental-wasi-modules", "--experimental-wasm-modules");
   AddOption("--experimental-policy",
             "use the specified file as a "
             "security policy",
diff --git a/src/node_options.h b/src/node_options.h
index 63892d3c477767..167866bb2f10b4 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -103,6 +103,7 @@ class EnvironmentOptions : public Options {
   bool experimental_modules = false;
   std::string es_module_specifier_resolution;
   bool experimental_wasm_modules = false;
+  bool experimental_wasi_modules = false;
   std::string module_type;
   std::string experimental_policy;
   bool experimental_repl_await = false;
diff --git a/src/node_wasi.cc b/src/node_wasi.cc
new file mode 100644
index 00000000000000..8ba8a426fe3e29
--- /dev/null
+++ b/src/node_wasi.cc
@@ -0,0 +1,133 @@
+#include <cerrno>
+#ifdef _WIN32
+#include <io.h>
+#include <processthreadsapi.h>
+#else
+#include <sys/types.h>
+#include <unistd.h>
+#include <sched.h>
+#endif
+#include <uv.h>
+
+#include "util-inl.h"
+#include "node_internals.h"
+
+#define NAPI_EXPERIMENTAL
+#include "node_api.h"
+
+namespace node {
+namespace wasi {
+
+napi_value Seek(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value args[3];
+  size_t argc = 3;
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+  if (status != napi_ok) {
+    return nullptr;
+  }
+
+  uint32_t fd;
+  status = napi_get_value_uint32(env, args[0], &fd);
+  if (status != napi_ok) {
+    return nullptr;
+  }
+
+  uint64_t offset;
+  bool lossless;
+  status = napi_get_value_bigint_uint64(env, args[1], &offset, &lossless);
+  if (status != napi_ok) {
+    return nullptr;
+  }
+
+  int32_t whence;
+  status = napi_get_value_int32(env, args[2], &whence);
+  if (status != napi_ok) {
+    return nullptr;
+  }
+
+#ifdef _WIN32
+  int64_t new_offset = _lseeki64(fd, offset, whence);
+#else
+  off_t new_offset = lseek(fd, offset, whence);
+#endif  // _WIN32
+
+  napi_value result;
+  if (new_offset == -1) {
+    status = napi_create_int32(env, errno, &result);
+  } else {
+    status = napi_create_bigint_uint64(env, new_offset, &result);
+  }
+  if (status != napi_ok) {
+    return nullptr;
+  }
+
+  return result;
+}
+
+napi_value SchedYield(napi_env, napi_callback_info) {
+#ifdef _WIN32
+  SwitchToThread();
+#else
+  sched_yield();
+#endif  // WIN32
+  return nullptr;
+}
+
+napi_value Realtime(napi_env env, napi_callback_info) {
+  uv_timeval64_t tv;
+  uv_gettimeofday(&tv);
+
+  uint64_t ns = tv.tv_sec * 1e9;
+  ns += tv.tv_usec * 1000;
+
+  napi_value result;
+  napi_status status = napi_create_bigint_uint64(env, ns, &result);
+
+  if (status != napi_ok) {
+    return nullptr;
+  }
+
+  return result;
+}
+
+napi_value Init(napi_env env, napi_value exports) {
+  napi_status status;
+
+#define V(f, name) \
+  { \
+    napi_value func; \
+    status = napi_create_function( \
+        env, name, NAPI_AUTO_LENGTH, f, nullptr, &func); \
+    if (status != napi_ok) { \
+      return nullptr; \
+    } \
+    status = napi_set_named_property(env, exports, name, func); \
+    if (status != napi_ok) { \
+      return nullptr; \
+    } \
+  }
+  V(Seek, "seek");
+  V(SchedYield, "schedYield");
+  V(Realtime, "realtime");
+#undef V
+
+#define V(n) \
+  { \
+    napi_value result; \
+    napi_create_int32(env, n, &result); \
+    napi_set_named_property(env, exports, #n, result); \
+  }
+  V(SEEK_SET);
+  V(SEEK_CUR);
+  V(SEEK_END);
+
+
+  return exports;
+}
+
+}  // namespace wasi
+}  // namespace node
+
+NODE_MODULE_CONTEXT_AWARE_INTERNAL_NAPI(wasi, node::wasi::Init)
diff --git a/test/fixtures/wasi/outside.txt b/test/fixtures/wasi/outside.txt
new file mode 100644
index 00000000000000..314e1615dd91a1
--- /dev/null
+++ b/test/fixtures/wasi/outside.txt
@@ -0,0 +1 @@
+hello from the outside!
diff --git a/test/fixtures/wasi/sandbox/input.txt b/test/fixtures/wasi/sandbox/input.txt
new file mode 100644
index 00000000000000..4c380537647f19
--- /dev/null
+++ b/test/fixtures/wasi/sandbox/input.txt
@@ -0,0 +1 @@
+hello from input.txt
diff --git a/test/fixtures/wasi/sandbox/notadir b/test/fixtures/wasi/sandbox/notadir
new file mode 100644
index 00000000000000..e69de29bb2d1d6
diff --git a/test/fixtures/wasi/sandbox/subdir/outside.txt b/test/fixtures/wasi/sandbox/subdir/outside.txt
new file mode 120000
index 00000000000000..2e0694706746f7
--- /dev/null
+++ b/test/fixtures/wasi/sandbox/subdir/outside.txt
@@ -0,0 +1 @@
+../../outside.txt
\ No newline at end of file
diff --git a/test/fixtures/wasi/sandbox/subdir1/input.txt b/test/fixtures/wasi/sandbox/subdir1/input.txt
new file mode 100644
index 00000000000000..4c380537647f19
--- /dev/null
+++ b/test/fixtures/wasi/sandbox/subdir1/input.txt
@@ -0,0 +1 @@
+hello from input.txt
diff --git a/test/fixtures/wasi/sandbox/subdir1/loop1 b/test/fixtures/wasi/sandbox/subdir1/loop1
new file mode 120000
index 00000000000000..8ac99eaab889e2
--- /dev/null
+++ b/test/fixtures/wasi/sandbox/subdir1/loop1
@@ -0,0 +1 @@
+../subdir2/loop2
\ No newline at end of file
diff --git a/test/fixtures/wasi/sandbox/subdir2/input_link.txt b/test/fixtures/wasi/sandbox/subdir2/input_link.txt
new file mode 100644
index 00000000000000..4c380537647f19
--- /dev/null
+++ b/test/fixtures/wasi/sandbox/subdir2/input_link.txt
@@ -0,0 +1 @@
+hello from input.txt
diff --git a/test/fixtures/wasi/sandbox/subdir2/loop2 b/test/fixtures/wasi/sandbox/subdir2/loop2
new file mode 120000
index 00000000000000..475be7b3cbbc9b
--- /dev/null
+++ b/test/fixtures/wasi/sandbox/subdir2/loop2
@@ -0,0 +1 @@
+../subdir1/loop1
\ No newline at end of file
diff --git a/test/wasi/README.md b/test/wasi/README.md
new file mode 100644
index 00000000000000..9975e27556f656
--- /dev/null
+++ b/test/wasi/README.md
@@ -0,0 +1,5 @@
+# WASI Tests
+
+Compile with clang and `wasm32-wasi` target. The clang version used must be
+built with wasi-sysroot. See `build.sh` in this directory for the exact
+commands used.
diff --git a/test/wasi/build.sh b/test/wasi/build.sh
new file mode 100755
index 00000000000000..ebdc6c52d0786a
--- /dev/null
+++ b/test/wasi/build.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -ex
+
+for file in c/*.c; do
+  filename=$(basename -- "$file")
+  filename="${filename%.*}"
+
+  /opt/wasi-sdk/bin/clang $file -target wasm32-unknown-wasi -o wasm/$filename.wasm
+done
diff --git a/test/wasi/c/cant_dotdot.c b/test/wasi/c/cant_dotdot.c
new file mode 100644
index 00000000000000..e2722062cd0156
--- /dev/null
+++ b/test/wasi/c/cant_dotdot.c
@@ -0,0 +1,11 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+
+int main() {
+  FILE* file = fopen("/sandbox/../outside.txt", "r");
+  assert(file == NULL);
+  assert(errno == ENOTCAPABLE);
+
+  return 0;
+}
diff --git a/test/wasi/c/clock_getres.c b/test/wasi/c/clock_getres.c
new file mode 100644
index 00000000000000..60a1c011e91865
--- /dev/null
+++ b/test/wasi/c/clock_getres.c
@@ -0,0 +1,12 @@
+#include <assert.h>
+#include <time.h>
+
+int main() {
+  struct timespec ts;
+
+  // supported clocks
+  assert(clock_getres(CLOCK_REALTIME, &ts) == 0);
+  assert(clock_getres(CLOCK_MONOTONIC, &ts) == 0);
+  assert(clock_getres(CLOCK_PROCESS_CPUTIME_ID, &ts) == 0);
+  assert(clock_getres(CLOCK_THREAD_CPUTIME_ID, &ts) == 0);
+}
diff --git a/test/wasi/c/exitcode.c b/test/wasi/c/exitcode.c
new file mode 100644
index 00000000000000..7267d42010ad2f
--- /dev/null
+++ b/test/wasi/c/exitcode.c
@@ -0,0 +1,5 @@
+// EXIT: 120
+
+int main() {
+  return 120;
+}
diff --git a/test/wasi/c/fd_prestat_get_refresh.c b/test/wasi/c/fd_prestat_get_refresh.c
new file mode 100644
index 00000000000000..fb644ab49b208a
--- /dev/null
+++ b/test/wasi/c/fd_prestat_get_refresh.c
@@ -0,0 +1,8 @@
+#include <unistd.h>
+
+int main(void) {
+  isatty(1);
+  __builtin_wasm_memory_grow(0, 1);
+  isatty(1);
+  return 0;
+}
diff --git a/test/wasi/c/follow_symlink.c b/test/wasi/c/follow_symlink.c
new file mode 100644
index 00000000000000..80932d4301106f
--- /dev/null
+++ b/test/wasi/c/follow_symlink.c
@@ -0,0 +1,15 @@
+// STDOUT: hello from input.txt\n
+
+#include <assert.h>
+#include <stdio.h>
+
+int main() {
+  FILE* file = fopen("/sandbox/subdir2/input_link.txt", "r");
+  assert(file != NULL);
+
+  char c = fgetc(file);
+  while (c != EOF) {
+    assert(fputc(c, stdout) != EOF);
+    c = fgetc(file);
+  }
+}
diff --git a/test/wasi/c/getentropy.c b/test/wasi/c/getentropy.c
new file mode 100644
index 00000000000000..4df6260aabebe7
--- /dev/null
+++ b/test/wasi/c/getentropy.c
@@ -0,0 +1,17 @@
+#include <assert.h>
+#include <unistd.h>
+
+int main() {
+  char buf[256] = {0};
+  assert(getentropy(buf, 256) == 0);
+
+  for (int i = 0; i < 256; i++) {
+    if (buf[i] != 0) {
+      return 0;
+    }
+  }
+
+  // if this ever is reached, we either have a bug or should buy a lottery
+  // ticket
+  return 1;
+}
diff --git a/test/wasi/c/getrusage.c b/test/wasi/c/getrusage.c
new file mode 100644
index 00000000000000..132b87deb5268c
--- /dev/null
+++ b/test/wasi/c/getrusage.c
@@ -0,0 +1,24 @@
+#include <assert.h>
+#include <sys/resource.h>
+
+int main() {
+  struct rusage ru1;
+  getrusage(RUSAGE_SELF, &ru1);
+
+  for (int i = 0; i < 1000; i++) {
+  }
+
+  struct rusage ru2;
+  getrusage(RUSAGE_SELF, &ru2);
+
+  // assert that some time has passed
+  long long s1 = ru1.ru_utime.tv_sec;
+  long long us1 = ru1.ru_utime.tv_usec;
+  long long s2 = ru2.ru_utime.tv_sec;
+  long long us2 = ru2.ru_utime.tv_usec;
+  assert(s1 <= s2);
+  if (s1 == s2) {
+    // strictly less than, so the timestamps can't be equal
+    assert(us1 < us2);
+  }
+}
diff --git a/test/wasi/c/gettimeofday.c b/test/wasi/c/gettimeofday.c
new file mode 100644
index 00000000000000..20ca5b0410c3c5
--- /dev/null
+++ b/test/wasi/c/gettimeofday.c
@@ -0,0 +1,25 @@
+#include <assert.h>
+#include <stdlib.h>
+#include <sys/time.h>
+
+int main() {
+  struct timeval tv1;
+  gettimeofday(&tv1, NULL);
+
+  for (int i = 0; i < 1000; i++) {
+  }
+
+  struct timeval tv2;
+  gettimeofday(&tv2, NULL);
+
+  // assert that some time has passed
+  long long s1 = tv1.tv_sec;
+  long long us1 = tv1.tv_usec;
+  long long s2 = tv2.tv_sec;
+  long long us2 = tv2.tv_usec;
+  assert(s1 <= s2);
+  if (s1 == s2) {
+    // strictly less than, so the timestamps can't be equal
+    assert(us1 < us2);
+  }
+}
diff --git a/test/wasi/c/notdir.c b/test/wasi/c/notdir.c
new file mode 100644
index 00000000000000..03f369ffd3a862
--- /dev/null
+++ b/test/wasi/c/notdir.c
@@ -0,0 +1,11 @@
+#include <assert.h>
+#include <dirent.h>
+#include <errno.h>
+
+int main() {
+  DIR* dir = opendir("/sandbox/notadir");
+  assert(dir == NULL);
+  assert(errno == ENOTDIR);
+
+  return 0;
+}
diff --git a/test/wasi/c/poll.c b/test/wasi/c/poll.c
new file mode 100644
index 00000000000000..6b6ef71fd68c3b
--- /dev/null
+++ b/test/wasi/c/poll.c
@@ -0,0 +1,31 @@
+#include <assert.h>
+#include <poll.h>
+#include <time.h>
+#include <unistd.h>
+
+int main(void) {
+  struct pollfd fds[2];
+  time_t before, now;
+  int ret;
+
+  fds[0] = (struct pollfd){.fd = 1, .events = POLLOUT, .revents = 0};
+  fds[1] = (struct pollfd){.fd = 2, .events = POLLOUT, .revents = 0};
+
+  ret = poll(fds, 2, -1);
+  assert(ret == 2);
+  assert(fds[0].revents == POLLOUT);
+  assert(fds[1].revents == POLLOUT);
+
+  fds[0] = (struct pollfd){.fd = 0, .events = POLLIN, .revents = 0};
+  time(&before);
+  ret = poll(fds, 1, 2000);
+  time(&now);
+  assert(ret == 0);
+  assert(now - before >= 2);
+
+  sleep(1);
+  time(&now);
+  assert(now - before >= 3);
+
+  return 0;
+}
diff --git a/test/wasi/c/preopen_populates.c b/test/wasi/c/preopen_populates.c
new file mode 100644
index 00000000000000..03b2213bb9a36c
--- /dev/null
+++ b/test/wasi/c/preopen_populates.c
@@ -0,0 +1,3 @@
+int main(void) {
+  return 0;
+}
diff --git a/test/wasi/c/read_file.c b/test/wasi/c/read_file.c
new file mode 100644
index 00000000000000..57fd9d3989b82f
--- /dev/null
+++ b/test/wasi/c/read_file.c
@@ -0,0 +1,15 @@
+// STDOUT: hello from input.txt\n
+
+#include <assert.h>
+#include <stdio.h>
+
+int main() {
+  FILE* file = fopen("/sandbox/input.txt", "r");
+  assert(file != NULL);
+
+  char c = fgetc(file);
+  while (c != EOF) {
+    assert(fputc(c, stdout) != EOF);
+    c = fgetc(file);
+  }
+}
diff --git a/test/wasi/c/read_file_twice.c b/test/wasi/c/read_file_twice.c
new file mode 100644
index 00000000000000..f88b6b4293e47c
--- /dev/null
+++ b/test/wasi/c/read_file_twice.c
@@ -0,0 +1,17 @@
+// STDOUT: hello from input.txt\nhello from input.txt\n
+
+#include <assert.h>
+#include <stdio.h>
+
+int main() {
+  for (int i = 0; i < 2; i++) {
+    FILE* file = fopen("/sandbox/input.txt", "r");
+    assert(file != NULL);
+
+    char c = fgetc(file);
+    while (c != EOF) {
+      assert(fputc(c, stdout) != EOF);
+      c = fgetc(file);
+    }
+  }
+}
diff --git a/test/wasi/c/stat.c b/test/wasi/c/stat.c
new file mode 100644
index 00000000000000..fd3854937b9e6e
--- /dev/null
+++ b/test/wasi/c/stat.c
@@ -0,0 +1,53 @@
+#include <sys/stat.h>
+
+#include <assert.h>
+#include <fcntl.h>
+#include <time.h>
+#include <unistd.h>
+
+#define BASE_DIR "/tmp"
+#define OUTPUT_DIR BASE_DIR "/testdir"
+#define PATH OUTPUT_DIR "/output.txt"
+#define SIZE 500
+
+int main(void) {
+  struct stat st;
+  int fd;
+  int ret;
+  off_t pos;
+
+  (void)st;
+  ret = mkdir(OUTPUT_DIR, 0755);
+  assert(ret == 0);
+
+  fd = open(PATH, O_CREAT | O_WRONLY, 0666);
+  assert(fd != -1);
+
+  pos = lseek(fd, SIZE - 1, SEEK_SET);
+  assert(pos == SIZE - 1);
+
+  ret = (int)write(fd, "", 1);
+  assert(ret == 1);
+
+  ret = fstat(fd, &st);
+  assert(ret == 0);
+  assert(st.st_size == SIZE);
+
+  ret = close(fd);
+  assert(ret == 0);
+
+  ret = access(PATH, R_OK);
+  assert(ret == 0);
+
+  ret = stat(PATH, &st);
+  assert(ret == 0);
+  assert(st.st_size == SIZE);
+
+  ret = unlink(PATH);
+  assert(ret == 0);
+
+  ret = stat(PATH, &st);
+  assert(ret == -1);
+
+  return 0;
+}
diff --git a/test/wasi/c/stdin.c b/test/wasi/c/stdin.c
new file mode 100644
index 00000000000000..72670552572ebc
--- /dev/null
+++ b/test/wasi/c/stdin.c
@@ -0,0 +1,16 @@
+// STDIN: hello world
+// STDOUT: hello world
+
+#include <stdio.h>
+
+int main(void) {
+  char x[32];
+
+  if (fgets(x, sizeof x, stdin) == NULL) {
+    return ferror(stdin);
+  }
+  if (fputs(x, stdout) == EOF) {
+    return ferror(stdout);
+  }
+  return 0;
+}
diff --git a/test/wasi/c/symlink_escape.c b/test/wasi/c/symlink_escape.c
new file mode 100644
index 00000000000000..32dcc64eebdc2b
--- /dev/null
+++ b/test/wasi/c/symlink_escape.c
@@ -0,0 +1,9 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+
+int main() {
+  FILE* file = fopen("/sandbox/subdir/outside.txt", "r");
+  assert(file == NULL);
+  assert(errno == ENOTCAPABLE);
+}
diff --git a/test/wasi/c/symlink_loop.c b/test/wasi/c/symlink_loop.c
new file mode 100644
index 00000000000000..dfc13d2c6a3bbb
--- /dev/null
+++ b/test/wasi/c/symlink_loop.c
@@ -0,0 +1,9 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+
+int main() {
+  FILE* file = fopen("/sandbox/subdir1/loop1", "r");
+  assert(file == NULL);
+  assert(errno == ELOOP);
+}
diff --git a/test/wasi/c/write_file.c b/test/wasi/c/write_file.c
new file mode 100644
index 00000000000000..0e1528463f26d7
--- /dev/null
+++ b/test/wasi/c/write_file.c
@@ -0,0 +1,15 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+static char* message = "hello, file!";
+
+int main() {
+  FILE* file = fopen("/tmp/output.txt", "w");
+  assert(file != NULL);
+
+  int nwritten = fprintf(file, "%s", message);
+  assert(nwritten == strlen(message));
+
+  assert(fclose(file) == 0);
+}
diff --git a/test/wasi/patch_preopen.js b/test/wasi/patch_preopen.js
new file mode 100644
index 00000000000000..37e0d9f0d7f656
--- /dev/null
+++ b/test/wasi/patch_preopen.js
@@ -0,0 +1,17 @@
+'use strict';
+
+require('../common');
+
+const tmpdir = require('../common/tmpdir');
+const fixtures = require('../common/fixtures');
+
+tmpdir.refresh();
+
+require('internal/wasi').defaultConfig = {
+  preopenDirectories: {
+    '/sandbox': fixtures.path('wasi/sandbox'),
+    '/tmp': tmpdir.path,
+  },
+  args: process.argv,
+  env: process.env,
+};
diff --git a/test/wasi/test-wasi.js b/test/wasi/test-wasi.js
new file mode 100644
index 00000000000000..6b1816737fe3ca
--- /dev/null
+++ b/test/wasi/test-wasi.js
@@ -0,0 +1,85 @@
+'use strict';
+
+require('../common');
+
+const cp = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+
+const SKIP = [
+  'poll',
+];
+
+const C_DIR = path.resolve(__dirname, 'c');
+const WASM_DIR = path.resolve(__dirname, 'wasm');
+
+// TODO(devsnek): remove this when V8 supports
+// bigint<->i64 on non-x64 platforms.
+if (process.arch !== 'x64') {
+  console.log('Skipping WASI tests on non-x64 platform');
+  return;
+}
+
+function parseOptions(string) {
+  const options = {};
+  for (const line of string.split('\n')) {
+    if (!line.startsWith('//')) {
+      break;
+    }
+    const [key, value] = line.slice(3).split(': ');
+    if (!key || !value) {
+      continue;
+    }
+    options[key] = value.replace(/\\n/g, '\n');
+  }
+  return options;
+}
+
+function exec(command, { stdin } = {}) {
+  try {
+    const stdout = cp.execSync(command, {
+      input: stdin,
+    });
+    return { code: 0, stdout: stdout.toString() };
+  } catch (e) {
+    if (e.status) {
+      return { code: e.status, stdout: '' };
+    }
+    throw e;
+  }
+}
+
+const ARGS = [
+  '--expose-internals',
+  `-r ${__dirname}/patch_preopen`,
+  '--experimental-wasm-bigint',
+  '--experimental-modules',
+  '--experimental-wasi-modules',
+].join(' ');
+
+fs.readdirSync(WASM_DIR).forEach((filename) => {
+  const file = filename.split('.')[0];
+
+  if (SKIP.includes(file)) {
+    return;
+  }
+
+  const source = fs.readFileSync(path.join(C_DIR, `${file}.c`), 'utf8');
+  const options = parseOptions(source);
+
+  console.log('Running', file);
+
+  const { code, stdout } =
+    exec(`${process.execPath} ${ARGS} ${WASM_DIR}/${filename}`, {
+      stdin: options.STDIN,
+    });
+
+  if (options.EXIT) {
+    assert.strictEqual(code, +options.EXIT);
+  } else {
+    assert.strictEqual(code, 0);
+  }
+
+  assert.strictEqual(stdout, options.STDOUT || '');
+});
diff --git a/test/wasi/testcfg.py b/test/wasi/testcfg.py
new file mode 100644
index 00000000000000..ec6cbc5fe3dc3a
--- /dev/null
+++ b/test/wasi/testcfg.py
@@ -0,0 +1,6 @@
+import sys, os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+import testpy
+
+def GetConfiguration(context, root):
+  return testpy.ParallelTestConfiguration(context, root, 'wasi')
diff --git a/test/wasi/wasi.status b/test/wasi/wasi.status
new file mode 100644
index 00000000000000..12212e8f72822b
--- /dev/null
+++ b/test/wasi/wasi.status
@@ -0,0 +1,7 @@
+prefix wasi
+
+# To mark a test as flaky, list the test name in the appropriate section
+# below, without ".js", followed by ": PASS,FLAKY". Example:
+# sample-test                        : PASS,FLAKY
+
+[true] # This section applies to all platforms
diff --git a/test/wasi/wasm/cant_dotdot.wasm b/test/wasi/wasm/cant_dotdot.wasm
new file mode 100755
index 00000000000000..e20c21a03d1977
Binary files /dev/null and b/test/wasi/wasm/cant_dotdot.wasm differ
diff --git a/test/wasi/wasm/clock_getres.wasm b/test/wasi/wasm/clock_getres.wasm
new file mode 100755
index 00000000000000..e691a815b35e55
Binary files /dev/null and b/test/wasi/wasm/clock_getres.wasm differ
diff --git a/test/wasi/wasm/exitcode.wasm b/test/wasi/wasm/exitcode.wasm
new file mode 100755
index 00000000000000..0254d61b907cee
Binary files /dev/null and b/test/wasi/wasm/exitcode.wasm differ
diff --git a/test/wasi/wasm/fd_prestat_get_refresh.wasm b/test/wasi/wasm/fd_prestat_get_refresh.wasm
new file mode 100755
index 00000000000000..612d3163527e40
Binary files /dev/null and b/test/wasi/wasm/fd_prestat_get_refresh.wasm differ
diff --git a/test/wasi/wasm/follow_symlink.wasm b/test/wasi/wasm/follow_symlink.wasm
new file mode 100755
index 00000000000000..b728b5e1863fdd
Binary files /dev/null and b/test/wasi/wasm/follow_symlink.wasm differ
diff --git a/test/wasi/wasm/getentropy.wasm b/test/wasi/wasm/getentropy.wasm
new file mode 100755
index 00000000000000..99a2cd8c887c10
Binary files /dev/null and b/test/wasi/wasm/getentropy.wasm differ
diff --git a/test/wasi/wasm/getrusage.wasm b/test/wasi/wasm/getrusage.wasm
new file mode 100755
index 00000000000000..39ce130d774dda
Binary files /dev/null and b/test/wasi/wasm/getrusage.wasm differ
diff --git a/test/wasi/wasm/gettimeofday.wasm b/test/wasi/wasm/gettimeofday.wasm
new file mode 100755
index 00000000000000..bec485f23a3857
Binary files /dev/null and b/test/wasi/wasm/gettimeofday.wasm differ
diff --git a/test/wasi/wasm/notdir.wasm b/test/wasi/wasm/notdir.wasm
new file mode 100755
index 00000000000000..6a03725621f6e3
Binary files /dev/null and b/test/wasi/wasm/notdir.wasm differ
diff --git a/test/wasi/wasm/poll.wasm b/test/wasi/wasm/poll.wasm
new file mode 100755
index 00000000000000..6f2c3bdbcd3e99
Binary files /dev/null and b/test/wasi/wasm/poll.wasm differ
diff --git a/test/wasi/wasm/preopen_populates.wasm b/test/wasi/wasm/preopen_populates.wasm
new file mode 100755
index 00000000000000..587bf37cdc04fe
Binary files /dev/null and b/test/wasi/wasm/preopen_populates.wasm differ
diff --git a/test/wasi/wasm/read_file.wasm b/test/wasi/wasm/read_file.wasm
new file mode 100755
index 00000000000000..3951f26a4f7158
Binary files /dev/null and b/test/wasi/wasm/read_file.wasm differ
diff --git a/test/wasi/wasm/read_file_twice.wasm b/test/wasi/wasm/read_file_twice.wasm
new file mode 100755
index 00000000000000..6221d1b5b6a924
Binary files /dev/null and b/test/wasi/wasm/read_file_twice.wasm differ
diff --git a/test/wasi/wasm/stat.wasm b/test/wasi/wasm/stat.wasm
new file mode 100755
index 00000000000000..b3423dc99df376
Binary files /dev/null and b/test/wasi/wasm/stat.wasm differ
diff --git a/test/wasi/wasm/stdin.wasm b/test/wasi/wasm/stdin.wasm
new file mode 100755
index 00000000000000..0611b1f90bcfac
Binary files /dev/null and b/test/wasi/wasm/stdin.wasm differ
diff --git a/test/wasi/wasm/symlink_escape.wasm b/test/wasi/wasm/symlink_escape.wasm
new file mode 100755
index 00000000000000..81e5094975627d
Binary files /dev/null and b/test/wasi/wasm/symlink_escape.wasm differ
diff --git a/test/wasi/wasm/symlink_loop.wasm b/test/wasi/wasm/symlink_loop.wasm
new file mode 100755
index 00000000000000..13756d747845b4
Binary files /dev/null and b/test/wasi/wasm/symlink_loop.wasm differ
diff --git a/test/wasi/wasm/write_file.wasm b/test/wasi/wasm/write_file.wasm
new file mode 100755
index 00000000000000..9c3bc4663325f1
Binary files /dev/null and b/test/wasi/wasm/write_file.wasm differ