diff --git a/include/swift/Basic/Lazy.h b/include/swift/Basic/Lazy.h
index 594e2ed8b9fcd..647e5aff41c59 100644
--- a/include/swift/Basic/Lazy.h
+++ b/include/swift/Basic/Lazy.h
@@ -16,12 +16,18 @@
 #include <memory>
 #ifdef __APPLE__
 #include <dispatch/dispatch.h>
+#elif defined(__wasi__)
+// No pthread on wasi
 #else
 #include <mutex>
 #endif
 #include "swift/Basic/Malloc.h"
 #include "swift/Basic/type_traits.h"
 
+#ifdef __wasi__
+void wasi_polyfill_call_once(int *flag, void *context, void (*func)(void *));
+#endif
+
 namespace swift {
 
 #ifdef __APPLE__
@@ -36,6 +42,10 @@ namespace swift {
   using OnceToken_t = unsigned long;
 # define SWIFT_ONCE_F(TOKEN, FUNC, CONTEXT) \
   _swift_once_f(&TOKEN, CONTEXT, FUNC)
+#elif defined(__wasi__)
+  using OnceToken_t = int;
+# define SWIFT_ONCE_F(TOKEN, FUNC, CONTEXT) \
+  ::wasi_polyfill_call_once(&TOKEN, CONTEXT, FUNC)
 #else
   using OnceToken_t = std::once_flag;
 # define SWIFT_ONCE_F(TOKEN, FUNC, CONTEXT) \
diff --git a/include/swift/Runtime/Mutex.h b/include/swift/Runtime/Mutex.h
index 3bf61177f9790..a24c555ccca03 100644
--- a/include/swift/Runtime/Mutex.h
+++ b/include/swift/Runtime/Mutex.h
@@ -20,10 +20,12 @@
 
 #include <type_traits>
 
-#if (defined(__APPLE__) || defined(__linux__) || defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__HAIKU__) || defined(__wasi__))
+#if (defined(__APPLE__) || defined(__linux__) || defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__HAIKU__))
 #include "swift/Runtime/MutexPThread.h"
 #elif defined(_WIN32)
 #include "swift/Runtime/MutexWin32.h"
+#elif defined(__wasi__)
+#include "swift/Runtime/MutexWASI.h"
 #else
 #error "Implement equivalent of MutexPThread.h/cpp for your platform."
 #endif
diff --git a/include/swift/Runtime/MutexWASI.h b/include/swift/Runtime/MutexWASI.h
new file mode 100644
index 0000000000000..28f212d6f48e9
--- /dev/null
+++ b/include/swift/Runtime/MutexWASI.h
@@ -0,0 +1,66 @@
+//===--- MutexWin32.h - -----------------------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Mutex, ConditionVariable, Read/Write lock, and Scoped lock implementations
+// using Windows Slim Reader/Writer Locks and Conditional Variables.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_RUNTIME_MUTEX_WASI_H
+#define SWIFT_RUNTIME_MUTEX_WASI_H
+
+namespace swift {
+
+typedef void* ConditionHandle;
+typedef void* MutexHandle;
+typedef void* ReadWriteLockHandle;
+
+#define SWIFT_CONDITION_SUPPORTS_CONSTEXPR 1
+#define SWIFT_MUTEX_SUPPORTS_CONSTEXPR 1
+#define SWIFT_READWRITELOCK_SUPPORTS_CONSTEXPR 1
+
+struct ConditionPlatformHelper {
+  static constexpr ConditionHandle staticInit() {
+    return nullptr;
+  };
+  static void init(ConditionHandle &condition) {}
+  static void destroy(ConditionHandle &condition) {}
+  static void notifyOne(ConditionHandle &condition) {}
+  static void notifyAll(ConditionHandle &condition) {}
+  static void wait(ConditionHandle &condition, MutexHandle &mutex);
+};
+
+struct MutexPlatformHelper {
+  static constexpr MutexHandle staticInit() { return nullptr; }
+  static void init(MutexHandle &mutex, bool checked = false) {}
+  static void destroy(MutexHandle &mutex) {}
+  static void lock(MutexHandle &mutex) {}
+  static void unlock(MutexHandle &mutex) {}
+  static bool try_lock(MutexHandle &mutex) { return true; }
+  static void unsafeLock(MutexHandle &mutex) {}
+  static void unsafeUnlock(MutexHandle &mutex) {}
+};
+
+struct ReadWriteLockPlatformHelper {
+  static constexpr ReadWriteLockHandle staticInit() { return nullptr; }
+  static void init(ReadWriteLockHandle &rwlock) {}
+  static void destroy(ReadWriteLockHandle &rwlock) {}
+  static void readLock(ReadWriteLockHandle &rwlock) {}
+  static bool try_readLock(ReadWriteLockHandle &rwlock) { return true; }
+  static void readUnlock(ReadWriteLockHandle &rwlock) {}
+  static void writeLock(ReadWriteLockHandle &rwlock) {}
+  static bool try_writeLock(ReadWriteLockHandle &rwlock) { return true; }
+  static void writeUnlock(ReadWriteLockHandle &rwlock) {}
+};
+}
+
+#endif
diff --git a/lib/ClangImporter/ClangImporter.cpp b/lib/ClangImporter/ClangImporter.cpp
index e60015f6530df..255102b42f926 100644
--- a/lib/ClangImporter/ClangImporter.cpp
+++ b/lib/ClangImporter/ClangImporter.cpp
@@ -598,6 +598,10 @@ getNormalInvocationArguments(std::vector<std::string> &invocationArgStrs,
       });
     }
 
+    if (triple.isOSWASI()) {
+      invocationArgStrs.insert(invocationArgStrs.end(), {"-D_WASI_EMULATED_MMAN"});
+    }
+
     if (triple.isOSWindows()) {
       switch (triple.getArch()) {
       default: llvm_unreachable("unsupported Windows architecture");
diff --git a/stdlib/private/SwiftPrivateThreadExtras/SwiftPrivateThreadExtras.swift b/stdlib/private/SwiftPrivateThreadExtras/SwiftPrivateThreadExtras.swift
index 831d721f3c588..c9d34e35017c2 100644
--- a/stdlib/private/SwiftPrivateThreadExtras/SwiftPrivateThreadExtras.swift
+++ b/stdlib/private/SwiftPrivateThreadExtras/SwiftPrivateThreadExtras.swift
@@ -98,6 +98,9 @@ public func _stdlib_thread_create_block<Argument, Result>(
   } else {
     return (0, ThreadHandle(bitPattern: threadID))
   }
+#elseif os(WASI)
+  // WASI environment has a only single thread
+  return (0, nil)
 #else
   var threadID = _make_pthread_t()
   let result = pthread_create(&threadID, nil,
@@ -128,6 +131,9 @@ public func _stdlib_thread_join<Result>(
   } else {
     return (CInt(result), nil)
   }
+#elseif os(WASI)
+  // WASI environment has a only single thread
+  return (0, nil)
 #else
   var threadResultRawPtr: UnsafeMutableRawPointer?
   let result = pthread_join(thread, &threadResultRawPtr)
diff --git a/stdlib/private/SwiftPrivateThreadExtras/ThreadBarriers.swift b/stdlib/private/SwiftPrivateThreadExtras/ThreadBarriers.swift
index b06ed029bf9b0..8bef3340ec82a 100644
--- a/stdlib/private/SwiftPrivateThreadExtras/ThreadBarriers.swift
+++ b/stdlib/private/SwiftPrivateThreadExtras/ThreadBarriers.swift
@@ -36,6 +36,8 @@ public struct _stdlib_thread_barrier_t {
 #elseif os(Cygwin) || os(FreeBSD)
   var mutex: UnsafeMutablePointer<pthread_mutex_t?>?
   var cond: UnsafeMutablePointer<pthread_cond_t?>?
+#elseif os(WASI)
+  // No pthread for WASI
 #else
   var mutex: UnsafeMutablePointer<pthread_mutex_t>?
   var cond: UnsafeMutablePointer<pthread_cond_t>?
@@ -67,6 +69,8 @@ public func _stdlib_thread_barrier_init(
 
   barrier.pointee.cond = UnsafeMutablePointer.allocate(capacity: 1)
   InitializeConditionVariable(barrier.pointee.cond!)
+#elseif os(WASI)
+  // WASI environment has a only single thread
 #else
   barrier.pointee.mutex = UnsafeMutablePointer.allocate(capacity: 1)
   if pthread_mutex_init(barrier.pointee.mutex!, nil) != 0 {
@@ -89,6 +93,8 @@ public func _stdlib_thread_barrier_destroy(
 #if os(Windows)
   // Condition Variables do not need to be explicitly destroyed
   // Mutexes do not need to be explicitly destroyed
+#elseif os(WASI)
+  // WASI environment has a only single thread
 #else
   if pthread_cond_destroy(barrier.pointee.cond!) != 0 {
     // FIXME: leaking memory, leaking a mutex.
@@ -99,11 +105,14 @@ public func _stdlib_thread_barrier_destroy(
     return -1
   }
 #endif
+
+#if !os(WASI)
   barrier.pointee.cond!.deinitialize(count: 1)
   barrier.pointee.cond!.deallocate()
 
   barrier.pointee.mutex!.deinitialize(count: 1)
   barrier.pointee.mutex!.deallocate()
+#endif
 
   return 0
 }
@@ -113,6 +122,8 @@ public func _stdlib_thread_barrier_wait(
 ) -> CInt {
 #if os(Windows)
   AcquireSRWLockExclusive(barrier.pointee.mutex!)
+#elseif os(WASI)
+  // WASI environment has a only single thread
 #else
   if pthread_mutex_lock(barrier.pointee.mutex!) != 0 {
     return -1
@@ -127,6 +138,8 @@ public func _stdlib_thread_barrier_wait(
       return -1
     }
     ReleaseSRWLockExclusive(barrier.pointee.mutex!)
+#elseif os(WASI)
+  // WASI environment has a only single thread
 #else
     if pthread_cond_wait(barrier.pointee.cond!, barrier.pointee.mutex!) != 0 {
       return -1
@@ -144,6 +157,8 @@ public func _stdlib_thread_barrier_wait(
 #if os(Windows)
     WakeAllConditionVariable(barrier.pointee.cond!)
     ReleaseSRWLockExclusive(barrier.pointee.mutex!)
+#elseif os(WASI)
+  // WASI environment has a only single thread
 #else
     if pthread_cond_broadcast(barrier.pointee.cond!) != 0 {
       return -1
diff --git a/stdlib/public/CMakeLists.txt b/stdlib/public/CMakeLists.txt
index e8d5da6490b76..5768d2168c373 100644
--- a/stdlib/public/CMakeLists.txt
+++ b/stdlib/public/CMakeLists.txt
@@ -62,6 +62,10 @@ if(SWIFT_BUILD_STDLIB)
   add_subdirectory(core)
   add_subdirectory(SwiftOnoneSupport)
 
+  if(WASI IN_LIST SWIFT_SDKS)
+    add_subdirectory(WASI)
+  endif()
+
   if(SWIFT_ENABLE_EXPERIMENTAL_DIFFERENTIABLE_PROGRAMMING)
     add_subdirectory(Differentiation)
   endif()
diff --git a/stdlib/public/Platform/glibc.modulemap.gyb b/stdlib/public/Platform/glibc.modulemap.gyb
index 963d3c7990cb7..b6171c8c321a0 100644
--- a/stdlib/public/Platform/glibc.modulemap.gyb
+++ b/stdlib/public/Platform/glibc.modulemap.gyb
@@ -377,11 +377,11 @@ module SwiftGlibc [system] {
       header "${GLIBC_INCLUDE_PATH}/poll.h"
       export *
     }
+% if CMAKE_SDK != "WASI":
     module pthread {
       header "${GLIBC_INCLUDE_PATH}/pthread.h"
       export *
     }
-% if CMAKE_SDK != "WASI":
     module pwd {
       header "${GLIBC_INCLUDE_PATH}/pwd.h"
       export *
diff --git a/stdlib/public/WASI/CMakeLists.txt b/stdlib/public/WASI/CMakeLists.txt
new file mode 100644
index 0000000000000..451f1f3af57d7
--- /dev/null
+++ b/stdlib/public/WASI/CMakeLists.txt
@@ -0,0 +1,3 @@
+add_swift_target_library(swiftWasiPthread STATIC IS_STDLIB
+  Pthread.cpp
+  INSTALL_IN_COMPONENT stdlib)
diff --git a/stdlib/public/WASI/Pthread.cpp b/stdlib/public/WASI/Pthread.cpp
new file mode 100644
index 0000000000000..5a64d9bdb4c39
--- /dev/null
+++ b/stdlib/public/WASI/Pthread.cpp
@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: 0BSD
+// prototypes taken from opengroup
+#include <stdlib.h>
+#include <stdio.h>
+#include <pthread.h>
+#include <semaphore.h>
+
+#define STUB() do {fprintf(stderr, "FakePthread: unsupported %s\n", __func__);abort();}while(0)
+
+// mutexes: just no-ops
+
+int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr) {
+	return 0;
+}
+
+int pthread_mutex_destroy(pthread_mutex_t *mutex) {
+	return 0;
+}
+
+int pthread_mutexattr_init(pthread_mutexattr_t *attr) {
+	return 0;
+}
+
+int pthread_mutexattr_destroy(pthread_mutexattr_t *attr) {
+	return 0;
+}
+
+int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type) {
+	return 0;
+}
+
+int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type) {
+	return 0;
+}
+
+int pthread_mutex_lock(pthread_mutex_t *mutex) {
+	return 0;
+}
+
+int pthread_mutex_trylock(pthread_mutex_t *mutex) {
+	return 0;
+}
+
+int pthread_mutex_unlock(pthread_mutex_t *mutex) {
+	return 0;
+}
+
+// pthread_cond: STUB
+
+int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr) {
+	return 0;
+}
+
+int pthread_cond_destroy(pthread_cond_t *cond) {
+	return 0;
+}
+
+int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) {
+	STUB();
+}
+
+int pthread_cond_timedwait(pthread_cond_t *cond, 
+    pthread_mutex_t *mutex, const struct timespec *abstime) {
+	STUB();
+}
+
+int pthread_cond_broadcast(pthread_cond_t *cond) {
+	return 0;
+}
+
+int pthread_cond_signal(pthread_cond_t *cond) {
+	return 0;
+}
+
+// tls
+
+int pthread_key_create(pthread_key_t *key, void (*destructor)(void*)) {
+	STUB();
+}
+
+void *pthread_getspecific(pthread_key_t key) {
+	STUB();
+}
+
+int pthread_setspecific(pthread_key_t key, const void *value) {
+	STUB();
+}
+
+// threads
+
+pthread_t pthread_self() {
+	return (pthread_t)1234;
+}
+
+#undef pthread_equal
+
+int pthread_equal(pthread_t t1, pthread_t t2) {
+	return t1 == t2;
+}
+
+int pthread_join(pthread_t thread, void **value_ptr) {
+	STUB();
+}
+
+int pthread_detach(pthread_t thread) {
+	STUB();
+}
+
+int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg) {
+	return 0;
+}
+
+// once
+
+int pthread_once(pthread_once_t *once_control, void (*init_routine)(void)) {
+	STUB();
+}
+
+// rwlock
+
+int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr) {
+	return 0;
+}
+
+int pthread_rwlock_destroy(pthread_rwlock_t *rwlock) {
+	return 0;
+}
+
+int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock) {
+	return 0;
+}
+
+int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock) {
+	return 0;
+}
+
+int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock) {
+	return 0;
+}
+
+int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock) {
+	return 0;
+}
+
+int pthread_rwlock_unlock(pthread_rwlock_t *rwlock) {
+	return 0;
+}
+
+// named semaphores
+
+sem_t *sem_open(const char *name, int oflag, ...) {
+	STUB();
+}
diff --git a/stdlib/public/runtime/CMakeLists.txt b/stdlib/public/runtime/CMakeLists.txt
index 702cf69df2207..1463033798a3b 100644
--- a/stdlib/public/runtime/CMakeLists.txt
+++ b/stdlib/public/runtime/CMakeLists.txt
@@ -56,6 +56,7 @@ set(swift_runtime_sources
     MetadataLookup.cpp
     MutexPThread.cpp
     MutexWin32.cpp
+    MutexWASI.cpp
     Numeric.cpp
     Once.cpp
     Portability.cpp
diff --git a/stdlib/public/runtime/Casting.cpp b/stdlib/public/runtime/Casting.cpp
index 2c516a9952fb4..0456b400611ee 100644
--- a/stdlib/public/runtime/Casting.cpp
+++ b/stdlib/public/runtime/Casting.cpp
@@ -30,7 +30,12 @@
 #include "swift/Runtime/ExistentialContainer.h"
 #include "swift/Runtime/HeapObject.h"
 #include "swift/Runtime/Metadata.h"
-#include "swift/Runtime/Mutex.h"
+#ifdef __wasi__
+# define SWIFT_CASTING_SUPPORTS_MUTEX 0
+#else
+# define SWIFT_CASTING_SUPPORTS_MUTEX 1
+# include "swift/Runtime/Mutex.h"
+#endif
 #include "swift/Runtime/Unreachable.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PointerIntPair.h"
@@ -125,7 +130,9 @@ TypeNamePair
 swift::swift_getTypeName(const Metadata *type, bool qualified) {
   using Key = llvm::PointerIntPair<const Metadata *, 1, bool>;
 
+  #if SWIFT_CASTING_SUPPORTS_MUTEX
   static StaticReadWriteLock TypeNameCacheLock;
+  #endif
   static Lazy<llvm::DenseMap<Key, std::pair<const char *, size_t>>>
     TypeNameCache;
   
@@ -134,7 +141,9 @@ swift::swift_getTypeName(const Metadata *type, bool qualified) {
 
   // Attempt read-only lookup of cache entry.
   {
+    #if SWIFT_CASTING_SUPPORTS_MUTEX
     StaticScopedReadLock guard(TypeNameCacheLock);
+    #endif
 
     auto found = cache.find(key);
     if (found != cache.end()) {
@@ -145,7 +154,9 @@ swift::swift_getTypeName(const Metadata *type, bool qualified) {
 
   // Read-only lookup failed to find item, we may need to create it.
   {
+    #if SWIFT_CASTING_SUPPORTS_MUTEX
     StaticScopedWriteLock guard(TypeNameCacheLock);
+    #endif
 
     // Do lookup again just to make sure it wasn't created by another
     // thread before we acquired the write lock.
diff --git a/stdlib/public/runtime/MutexPThread.cpp b/stdlib/public/runtime/MutexPThread.cpp
index 62e718c16abaa..92db58226cd09 100644
--- a/stdlib/public/runtime/MutexPThread.cpp
+++ b/stdlib/public/runtime/MutexPThread.cpp
@@ -15,7 +15,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if !defined(_WIN32)
+#if !defined(_WIN32) && !defined(__wasi__)
 #include "swift/Runtime/Mutex.h"
 
 #include "swift/Runtime/Debug.h"
diff --git a/stdlib/public/runtime/MutexWASI.cpp b/stdlib/public/runtime/MutexWASI.cpp
new file mode 100644
index 0000000000000..6288ecce03449
--- /dev/null
+++ b/stdlib/public/runtime/MutexWASI.cpp
@@ -0,0 +1,25 @@
+//===--- MutexWin32.cpp - -------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Mutex, ConditionVariable, Read/Write lock, and Scoped lock implementations
+// using Windows Slim Reader/Writer Locks and Conditional Variables.
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__wasi__)
+#include "swift/Runtime/Mutex.h"
+
+using namespace swift;
+
+void ConditionPlatformHelper::wait(void* &condition,
+                                   void* &mutex) {}
+#endif
diff --git a/stdlib/public/runtime/ThreadLocalStorage.h b/stdlib/public/runtime/ThreadLocalStorage.h
index ebf57f6ceb69a..4e62b76b1d74e 100644
--- a/stdlib/public/runtime/ThreadLocalStorage.h
+++ b/stdlib/public/runtime/ThreadLocalStorage.h
@@ -98,7 +98,13 @@ static_assert(std::is_same<__swift_thread_key_t, DWORD>::value,
 #  define SWIFT_THREAD_KEY_CREATE _stdlib_thread_key_create
 #  define SWIFT_THREAD_GETSPECIFIC FlsGetValue
 #  define SWIFT_THREAD_SETSPECIFIC(key, value) (FlsSetValue(key, value) == FALSE)
-
+# elif defined(__wasi__)
+int   wasi_polyfill_pthread_key_create(__swift_thread_key_t *key, void (*destructor)(void*));
+void *wasi_polyfill_pthread_getspecific(__swift_thread_key_t key);
+int   wasi_polyfill_pthread_setspecific(__swift_thread_key_t key, const void *value);
+#  define SWIFT_THREAD_KEY_CREATE  wasi_polyfill_pthread_key_create
+#  define SWIFT_THREAD_GETSPECIFIC wasi_polyfill_pthread_getspecific
+#  define SWIFT_THREAD_SETSPECIFIC wasi_polyfill_pthread_setspecific
 # else
 // Otherwise use the pthread API.
 #  include <pthread.h>
diff --git a/stdlib/public/stubs/ThreadLocalStorage.cpp b/stdlib/public/stubs/ThreadLocalStorage.cpp
index 50168f955bc6c..4e855cb593b72 100644
--- a/stdlib/public/stubs/ThreadLocalStorage.cpp
+++ b/stdlib/public/stubs/ThreadLocalStorage.cpp
@@ -25,6 +25,26 @@ void *_stdlib_createTLS(void);
 
 #if !SWIFT_TLS_HAS_RESERVED_PTHREAD_SPECIFIC || (defined(_WIN32) && !defined(__CYGWIN__))
 
+#if defined(__wasi__)
+#define STUB() do { /* fprintf(stderr, "%s is unsupported on WASI environment\n", __func__);*/ abort(); } while(0)
+void wasi_polyfill_call_once(int *flag, void *context, void (*func)(void *))
+ {
+    switch (*flag) {
+    case 0:
+      func(context);
+      *flag = 1;
+      return;
+    case 1:
+      return;
+    default:
+      STUB();
+    }
+  }
+int   wasi_polyfill_pthread_key_create(__swift_thread_key_t *key, void (*destructor)(void*)) { STUB(); }
+void *wasi_polyfill_pthread_getspecific(__swift_thread_key_t key) { STUB(); }
+int   wasi_polyfill_pthread_setspecific(__swift_thread_key_t key, const void *value) { STUB(); }
+#endif
+
 static void
 #if defined(_M_IX86)
 __stdcall
diff --git a/utils/webassembly/static-executable-args.lnk b/utils/webassembly/static-executable-args.lnk
index 0f8105ca97de6..d80b4a58a272c 100644
--- a/utils/webassembly/static-executable-args.lnk
+++ b/utils/webassembly/static-executable-args.lnk
@@ -2,13 +2,15 @@
 -lswiftCore
 -lswiftImageInspectionShared
 -lswiftSwiftOnoneSupport
+-lswiftWasiPthread
 -licui18n
 -licuuc
 -licudata
 -ldl
 -lstdc++
 -lm
+-lwasi-emulated-mman
 -Xlinker --error-limit=0
 -Xlinker --no-gc-sections
 -Xlinker --no-threads
-
+-D_WASI_EMULATED_MMAN
diff --git a/utils/webassembly/static-stdlib-args.lnk b/utils/webassembly/static-stdlib-args.lnk
index 5d1397e2b74b8..af390c6413bd2 100644
--- a/utils/webassembly/static-stdlib-args.lnk
+++ b/utils/webassembly/static-stdlib-args.lnk
@@ -1,6 +1,6 @@
 -ldl
--lpthread
 -latomic
+-lswiftWasiPthread
 -lswiftCore
 -latomic
 -lswiftImageInspectionShared