ldc-developers · kinke · Aug 26, 2026 · Aug 10, 2026 · Aug 10, 2026 · Aug 10, 2026
diff --git a/.github/actions/1a-setup-emscripten/action.yml b/.github/actions/1a-setup-emscripten/action.yml
@@ -0,0 +1,18 @@
+name: "Emscripten: Install additional prerequisites"
+inputs:
+  emsdk_version:
+    required: false
+    default: '6.0.8'
+runs:
+  using: composite
+  steps:
+    - name: "Install emsdk" # into ../emsdk
+      shell: bash
+      run: |
+        set -eux
+        cd ..
+
+        git clone https://github.com/emscripten-core/emsdk.git
+        cd emsdk
+        ./emsdk install '${{ inputs.emsdk_version }}'
+        ./emsdk activate '${{ inputs.emsdk_version }}'
diff --git a/.github/actions/4b-test-lit/action.yml b/.github/actions/4b-test-lit/action.yml
@@ -23,8 +23,7 @@ runs:
         fi
 
         cd ../build
-        # temporarily add LLVM bin dir to PATH, so that e.g. wasm-ld is found
-        PATH="$PWD/../llvm/bin:$PATH" ctest -V -R "lit-tests"
+        ctest -V -R "lit-tests"
 
     - name: 'Windows: Run LIT testsuite'
       if: runner.os == 'Windows'

diff --git a/.github/actions/5a-emscripten/action.yml b/.github/actions/5a-emscripten/action.yml
@@ -0,0 +1,65 @@
+name: "Emscripten: Cross-compile druntime & phobos incl. test runners, install libs + .conf, run druntime & phobos unittests"
+inputs:
+  arch:
+    required: true
+runs:
+  using: composite
+  steps:
+    - name: Cross-compile druntime & phobos incl. test runners & install libs + .conf
+      shell: bash
+      run: |
+        set -eux
+        cd ..
+
+        os='emscripten'
+        arch='${{ inputs.arch }}'
+        triple="$arch-unknown-$os"
+
+        bootstrap-ldc/bin/ldc-build-runtime \
+          --ninja \
+          --dFlags="-mtriple=$triple" \
+          --linkerFlags="--preload-file;/usr/share/zoneinfo" \
+          --ldcSrcDir="$PWD/ldc" \
+          --installWithSuffix="-$os-$arch" \
+          --testrunners \
+          CMAKE_INSTALL_PREFIX="$PWD/install" \
+          RT_CONF_TRIPLE_REGEX="$arch-.*-$os" \
+          CMAKE_TOOLCHAIN_FILE="$PWD/emsdk/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake" \
+          BUILD_LTO_LIBS=ON
+
+    - name: Run druntime unittests
+      shell: bash
+      run: |
+        set -eux
+        cd ../ldc-build-runtime.tmp
+
+        ../emsdk/node/*/bin/node ./druntime-test-runner-debug.js
+        ../emsdk/node/*/bin/node ./druntime-test-runner.js
+
+    - name: Run phobos unittests
+      shell: bash
+      run: |
+        set -eux
+        cd ../ldc-build-runtime.tmp
+
+        ../emsdk/node/*/bin/node ./phobos2-test-runner-debug.js
+        ../emsdk/node/*/bin/node ./phobos2-test-runner.js
+
+    - name: Run `importc_compare`
+      shell: bash
+      run: |
+        set -eux
+        cd ..
+
+        os='emscripten'
+        arch='${{ inputs.arch }}'
+        triple="$arch-unknown-$os"
+
+        bootstrap-ldc/bin/ldc2 \
+          -defaultlib=druntime-ldc -L-Linstall/lib-$os-$arch \
+          -gcc="$PWD/emsdk/upstream/emscripten/emcc" \
+          --mtriple=$triple \
+          -I$PWD/ldc/runtime/druntime/test/importc_compare/src \
+          $PWD/ldc/runtime/druntime/test/importc_compare/src/importc_compare.d
+
+        emsdk/node/*/bin/node ./importc_compare.js
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
@@ -387,6 +387,10 @@ jobs:
       matrix:
         include:
           - job_name: WASI wasm32
+            os: wasi
+            arch: wasm32
+          - job_name: Emscripten wasm32
+            os: emscripten
             arch: wasm32
     name: ${{ matrix.job_name }}
     runs-on: ubuntu-22.04-arm
@@ -404,26 +408,37 @@ jobs:
           clang_major: ${{ env.CLANG_MAJOR }}
           arch: aarch64
       - name: 'WASI: Install additional prerequisites'
+        if: matrix.os == 'wasi'
         uses: ./.github/actions/1a-setup-wasi
+      - name: 'Emscripten: Install additional prerequisites'
+        if: matrix.os == 'emscripten'
+        uses: ./.github/actions/1a-setup-emscripten
       - name: Build bootstrap LDC
         uses: ./.github/actions/2-build-bootstrap
       - name: 'WASIp1: Cross-compile druntime & phobos incl. test runners & run druntime & phobos unittests'
+        if: matrix.os == 'wasi'
         uses: ./.github/actions/5a-wasi
         with:
           os: wasip1
           arch: ${{ matrix.arch }}
       - name: 'WASIp2: Cross-compile druntime & phobos incl. test runners & run druntime & phobos unittests'
+        if: matrix.os == 'wasi'
         uses: ./.github/actions/5a-wasi
         with:
           os: wasip2
           arch: ${{ matrix.arch }}
+      - name: 'Emscripten: Cross-compile druntime & phobos incl. test runners & run druntime & phobos unittests'
+        if: matrix.os == 'emscripten'
+        uses: ./.github/actions/5a-emscripten
+        with:
+          arch: ${{ matrix.arch }}
       - name: Make installed .conf files portable
         uses: ./.github/actions/5b-make-portable
       - name: Create addon package & upload artifact
         uses: ./.github/actions/7-package
         with:
           arch: ${{ matrix.arch }}
-          os: wasi
+          os: ${{ matrix.os }}
           is_addon: true
       - name: Smoke-test add-on package
         run: |
@@ -433,17 +448,29 @@ jobs:
           tar xf ${{ github.workspace }}/artifacts/*-addon-*.tar.xz
           # generate hello.d
           echo 'void main() { import std.stdio; writefln!"Hello world, %d bits"(size_t.sizeof * 8); }' > hello.d
-          # put WASI-SDK clang onto PATH
-          export PATH="$WASI_SDK_PATH/bin:$PATH"
-          # build & run hello-world
-          for os in wasip1 wasip2; do
-            # test LTO too
+
+          if [[ '${{ matrix.os }}' == wasi ]]; then
+            # put WASI-SDK clang onto PATH
+            export PATH="$WASI_SDK_PATH/bin:$PATH"
+            # build & run hello-world
+            for os in wasip1 wasip2; do
+              # test LTO too
+              for args in "" "-O -flto=full -defaultlib=druntime-ldc-lto,phobos2-ldc-lto"; do
+                bin/ldc2 -mtriple=${{ matrix.arch }}-unknown-$os $args hello.d
+                ls -l hello.wasm
+                wasmtime ./hello.wasm
+              done
+            done
+          elif [[ '${{ matrix.os }}' == emscripten ]]; then
+            # put emcc onto PATH
+            export PATH="$PWD/../emsdk/upstream/emscripten:$PATH"
+            # build & run hello-world
             for args in "" "-O -flto=full -defaultlib=druntime-ldc-lto,phobos2-ldc-lto"; do
-              bin/ldc2 -mtriple=${{ matrix.arch }}-unknown-$os $args hello.d
-              ls -l hello.wasm
-              wasmtime ./hello.wasm
+              bin/ldc2 -mtriple=${{ matrix.arch }}-unknown-emscripten $args hello.d
+              ls -l hello.{js,wasm}
+              ../emsdk/node/*/bin/node ./hello.js
             done
-          done
+          fi
 
 
   merge-macos:

diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -5,11 +5,12 @@
   - `-foptimize-nothrow` is the default setting when targeting Windows or WebAssembly, to make hitting https://github.com/ldc-developers/ldc/issues/3504 much less likely.
 - Support for [LLVM 22](https://releases.llvm.org/22.1.0/docs/ReleaseNotes.html). The prebuilt packages use v22.1.8. (#5097, #5102, #5172)
 - Minimum LLVM version raised to 18. (#5094)
-- DRuntime and Phobos now support [WASI](https://github.com/WebAssembly/WASI) preview levels 1 and 2, based on [`wasi-libc`](https://github.com/WebAssembly/wasi-libc). Two caveats being that WASI is strictly single-threaded (currently), and that fibers are unavailable. (#5186, #5229, #5230, #5242)
+- DRuntime and Phobos now support [WASI](https://github.com/WebAssembly/WASI) preview levels 1 and 2, based on [`wasi-libc`](https://github.com/WebAssembly/wasi-libc), as well as [Emscripten](https://emscripten.org/). Two caveats being that WASI (and our Emscripten support) is strictly single-threaded (currently), and that fibers are unavailable. (#5186, #5229, #5230, #5242, #5259)
 - New prebuilt **addon packages** (`ldc2-*-addon-<target OS>.tar.xz`) for simple cross-compilation. Simply unpack them directly into your LDC installation directory, and then cross-compile via `-mtriple=…` (or `dub --target=…`): (#5240)
   - Windows: `x86_64-windows-msvc`, `i686-windows-msvc`; no SDK required.
   - Android: `aarch64-linux-android30`, `armv7a-linux-androideabi29`, `x86_64-linux-android29`, `i686-linux-android29`; needs an [Android NDK](https://developer.android.com/ndk/downloads) (r27) and its `toolchains/llvm/prebuilt/*/bin/` dir in your PATH.
   - WASI: `wasm32-unknown-wasip1`, `wasm32-unknown-wasip2`; needs a [WASI SDK](https://github.com/webassembly/wasi-sdk) and its `bin/` dir in your PATH. (#5207, #5242)
+  - Emscripten: `wasm32-unknown-emscripten`; needs a [Emscripten SDK](https://github.com/emscripten-core/emsdk) and its `upstream/emscripten/` dir in your PATH. (#5259)
 - The `@ldc.attributes.restrict` UDA is now supported for dynamic-array parameters too. Builtin array ops (`c[] = a[] * b[]` etc.) use it, enabling auto-vectorization. Note that for such array ops, the dlang spec prescribes that the slice on the left and any slices on the right must not overlap (https://dlang.org/spec/arrays.html#array-operations), and this knowledge is now used by the optimizer; e.g., `x[] *= x[]` is invalid. (#5148, #5168, #5176)
 - DMD-style inline assembly: `asm { naked; }` is now much less of a special case wrt. codegen - such naked functions are now emitted as if `asm { naked; }` was replaced with the `@naked` function UDA. IR-wise, they are not emitted as module-level asm blobs anymore, but regular IR functions. This should lift a few former `asm { naked; }`-specific restrictions and fixed at least one LTO issue. (#5041)
 - **dcompute**: Added support for Native device code Embedding (PTX and SPIR-V) into the host executable's `.rodata` section. (#5140)

diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -952,17 +952,20 @@ makeConfSection(NAME "51-target-wasm-base"
         ${wasm_eh_switches}
 )
 
-# Add a convenience config for *naked* wasm targets, omitting druntime/Phobos
+# Add a convenience config for *naked* wasm targets, omitting druntime/Phobos/libc
 # (and preferring built-in lld for linking) automatically.
-set(wasm_naked_link_internally)
+set(wasm_naked_switches)
 if(LDC_WITH_LLD)
-    set(wasm_naked_link_internally -link-internally)
+    list(APPEND wasm_naked_switches -link-internally)
+else()
+    # clang as default cross-linker driver usually works, with -nostdlib
+    list(APPEND wasm_naked_switches -Xcc=-nostdlib)
 endif()
 makeConfSection(NAME "55-target-wasm-naked"
     SECTION "^wasm(32|64)-.*-(unknown|none)"
     SWITCHES
         -defaultlib=
-        ${wasm_naked_link_internally}
+        ${wasm_naked_switches}
     LIB_DIRS OVERRIDE
 )
 

diff --git a/driver/linker-gcc.cpp b/driver/linker-gcc.cpp
@@ -635,6 +635,8 @@ void ArgsBuilder::addLinker() {
 //////////////////////////////////////////////////////////////////////////////
 
 void ArgsBuilder::addUserSwitches() {
+  const bool isEmcc = global.params.targetTriple->isOSEmscripten();
+
   // additional linker and cc switches (preserve order across both lists)
   for (unsigned ilink = 0, icc = 0;;) {
     unsigned linkpos = ilink < opts::linkerSwitches.size()
@@ -654,7 +656,14 @@ void ArgsBuilder::addUserSwitches() {
       if (!(str.starts_with("-l") || str.starts_with("-L") ||
             str.starts_with("-Wl,") || str.starts_with("-shared") ||
             str.starts_with("-static"))) {
-        args.push_back("-Xlinker");
+        // avoid `-Xlinker <p>` for Emscripten's emcc, seems buggy; use
+        // `-Wl,<p>` instead
+        if (isEmcc) {
+          args.push_back("-Wl," + p);
+          continue;
+        } else {
+          args.push_back("-Xlinker");
+        }
       }
       args.push_back(p);
     } else if (ccpos < linkpos) {
@@ -807,16 +816,8 @@ int linkObjToBinaryGcc(llvm::StringRef outputPath,
 #endif
 
   // build command-line for gcc-compatible linker driver
-  // exception: invoke (ld-compatible) linker directly for WebAssembly targets
-  std::string tool;
-  std::unique_ptr<ArgsBuilder> argsBuilder;
-  if (global.params.targetTriple->isOSBinFormatWasm() && !global.params.targetTriple->isOSWASI()) {
-    argsBuilder = std::make_unique<LdArgsBuilder>();
-    tool = getProgram("wasm-ld", &opts::linker);
-  } else {
-    argsBuilder = std::make_unique<ArgsBuilder>();
-    tool = getCC(argsBuilder->args);
-  }
+  auto argsBuilder = std::make_unique<ArgsBuilder>();
+  std::string tool = getCC(argsBuilder->args);
 
   // build arguments
   argsBuilder->build(outputPath, defaultLibNames);

diff --git a/driver/linker.cpp b/driver/linker.cpp
@@ -103,9 +103,8 @@ static std::string getOutputPath() {
     extension = target.dll_ext.ptr;
   } else if (triple.isOSWindows()) {
     extension = "exe";
-  } else if (triple.getArch() == llvm::Triple::wasm32 ||
-             triple.getArch() == llvm::Triple::wasm64) {
-    extension = "wasm";
+  } else if (triple.isWasm()) {
+    extension = triple.isOSEmscripten() ? "js" : "wasm";
   }
 
   if (global.params.exefile.length) {

diff --git a/driver/main.cpp b/driver/main.cpp
@@ -960,8 +960,8 @@ void registerPredefinedTargetVersions() {
 #endif
   case llvm::Triple::Emscripten:
     VersionCondition::addPredefinedGlobalIdent("Emscripten");
-    // Emscripten uses musl and libc++, so mimic a musl Linux platform:
-    VersionCondition::addPredefinedGlobalIdent("linux");
+    VersionCondition::addPredefinedGlobalIdent("WASI");
+    VersionCondition::addPredefinedGlobalIdent("WASIp1");
     VersionCondition::addPredefinedGlobalIdent("Posix");
     VersionCondition::addPredefinedGlobalIdent("CRuntime_Musl");
     VersionCondition::addPredefinedGlobalIdent("CppRuntime_LLVM");

diff --git a/driver/tool.cpp b/driver/tool.cpp
@@ -96,6 +96,8 @@ llvm::SmallVector<std::string, 2> findCCFallback() {
       choices = {{"wasm32-wasi-clang"}};
       break;
     }
+  } else if (triple.isOSEmscripten()) {
+    choices = { { "emcc" } };
   } else {
     choices = {
       { opts::mTargetTriple + "-gcc" },

diff --git a/runtime/CMakeLists.txt b/runtime/CMakeLists.txt
@@ -310,6 +310,13 @@ if(NOT PHOBOS2_DIR)
     list(APPEND switches -defaultlib=druntime-ldc)
 endif()
 
+# Default to letting Emscripten executables grow their memory.
+if("${TARGET_SYSTEM}" MATCHES "Emscripten")
+    list(APPEND switches "-Xcc=-sALLOW_MEMORY_GROWTH")
+    # also for the druntime/Phobos test runners
+    append("-sALLOW_MEMORY_GROWTH" LD_FLAGS)
+endif()
+
 set(build_libdir "${CMAKE_BINARY_DIR}/lib${LIB_SUFFIX}")
 set(install_libdir "${CMAKE_INSTALL_LIBDIR}")
 

diff --git a/runtime/druntime/src/core/demangle.d b/runtime/druntime/src/core/demangle.d
@@ -3003,6 +3003,7 @@ CXX_DEMANGLER getCXXDemangler() nothrow @trusted
         version (OpenBSD) import core.sys.openbsd.dlfcn : RTLD_DEFAULT;
         version (Darwin) import core.sys.darwin.dlfcn : RTLD_DEFAULT;
         version (Solaris) import core.sys.solaris.dlfcn : RTLD_DEFAULT;
+        version (Emscripten) import core.sys.posix.dlfcn : RTLD_DEFAULT;
         version (CRuntime_WASI) import core.sys.posix.dlfcn : RTLD_DEFAULT;
 
         if (auto found = cast(CXX_DEMANGLER) dlsym(RTLD_DEFAULT, "__cxa_demangle"))

diff --git a/runtime/druntime/src/core/stdc/config.d b/runtime/druntime/src/core/stdc/config.d
@@ -638,7 +638,9 @@ version (unittest)
 // https://musl.libc.org/time64.html
 version (CRuntime_Musl)
 {
-    version (CRuntime_Musl_Pre_Time64)
+    version (Emscripten)
+        enum muslRedirTime64 = false;
+    else version (CRuntime_Musl_Pre_Time64)
         enum muslRedirTime64 = false;
     else
     {