wasm-idle

Executes C, C++, Objective-C, Objective-C++, Fortran, COBOL, V, Python, Java, Rust, Go, D, C#, F#, VB.NET, Elixir, Erlang, Prolog, Gleam, Grain, Perl, Tcl, AWK, Pascal, Forth, J, BQN, Janet, Julia, Nim, Bash, ClojureScript, ReScript, OCaml, JavaScript, TypeScript, AssemblyScript, WAT, WASM, Lua, Fennel, Zig, Scheme, Ruby, Haskell, R, Octave, SQLite, DuckDB, PostgreSQL, and PHP code.

Experimental LFortran execution is available separately from f2c Fortran; see the LFortran consumer contract and local setup.

Lean 4 runs the upstream lean --run interpreter in the browser; see Lean 4 browser execution.

V runs the real V 0.5.2 compiler in the browser and compiles its C output with the shared llvm-core Clang host; see the V browser integration.

The browser-side C-family host is provided by @wasm-idle/llvm-core. Compiler source pins, patches, and reproducible asset builds live in seo-rii/wasm-llvm; wasm-idle loads the generated artifacts from external URLs instead of embedding them in npm packages.

Verified downloads can be retained across reloads using a version-pinned, capacity-bounded CacheStorage/IndexedDB cache. See persistent asset cache configuration and coverage for global/per-call opt-out, cleanup and prefetch APIs.

Language support policy

wasm-idle language support must run user code through the real language implementation in the browser, normally via a WebAssembly compiler, interpreter, or runtime. Do not add handwritten parsers, translators, emulators, or "subset" executors as language support. A language should be listed only after normal user code runs on that actual runtime and stdin/stdout behavior, or a documented stdin limitation, is covered by tests.

Support matrix

All execution entries run in the browser through real runtime, compiler, or interpreter implementations. Editor support lists browser LSP/compiler diagnostics when wired; syntax means Monaco syntax highlighting only. C, C++, and wasm32-wasip1 Rust use the browser LLDB/WAMR debug runtime; the remaining debug-enabled languages retain wasm-idle's trace controls.

| Language | Browser runtime/compiler | Stdin | Editor support | Debug | | -------------- | -------------------------------------------- | ----- | -------------------- | ----- | | GolfScript | Original GolfScript interpreter on Ruby/WASI | Yes | plain text | - | | APECode | Original APECode interpreter on Pyodide | Yes | plain text | - | | LOLCODE 1.3 | Original lci 1.3 interpreter on WASI | Yes | plain text | - | | UHMLANG (엄준식) | Original Umjunsik Go interpreter on WASI | Yes | plain text | - | | Aheui | rpaheui 1.2.5 on Pyodide | Yes | plain text | - | | Malbolge | Ben Olmstead Malbolge on WASI | Yes | plain text | - | | Whitespace | koturn/Whitespace 0.3 on WASI | Yes | plain text | - | | C3 | C3 0.8.3 + LLVM/lld WASM (byte ABI) | Yes | compiler diagnostics | - | | C | @wasm-idle/llvm-core / Clang WASI | Yes | clangd | LLDB | | C++ | @wasm-idle/llvm-core / Clang WASI | Yes | clangd | LLDB | | Objective-C | GNUstep libobjc2 + @wasm-idle/llvm-core | Yes | clangd | Trace | | Objective-C++ | GNUstep libobjc2 + @wasm-idle/llvm-core | Yes | clangd | - | | Python | Pyodide | Yes | Python LSP | Trace | | Befunge-93 | Chris Pressey Befunge-93 on WASI | Yes | plain text | - | | Brainfuck | susam/bfc on WASI | Yes | plain text | - | | Hy | Hy 1.3.1 on Pyodide | Yes | syntax | - | | Java | TeaVM | Yes | syntax | - | | Rust | wasm-rust / browser rustc | Yes | rustc diagnostics | LLDB | | Go | wasm-go / browser Go compiler | Yes | compiler diagnostics | Trace | | D | wasm-d | Yes | syntax | - | | C# | wasm-dotnet | Yes | compiler diagnostics | - | | F# | wasm-dotnet | Yes | compiler diagnostics | - | | VB.NET | wasm-dotnet | Yes | compiler diagnostics | - | | Elixir | AtomVM / Popcorn | Yes | syntax | - | | Erlang | AtomVM / Popcorn | Yes | syntax | - | | Prolog | SWI-Prolog WASM worker | Yes | syntax | - | | Gleam | Gleam precompiled browser runtime | Yes | compiler diagnostics | - | | Grain | Grain 0.7.2 js_of_ocaml compiler + WASI | Yes | compiler diagnostics | - | | Perl | Perl WASM worker | Yes | syntax | - | | Tcl | Wacl Tcl WASM worker | Yes | syntax | - | | AWK | GoAWK WASM worker | Yes | syntax | - | | Pascal | pas2js worker | Yes | syntax | - | | Forth | WAForth WASM worker | Yes | syntax | - | | J | J playground WASM worker | Yes | syntax | - | | BQN | CBQN WASM worker | Yes | syntax | - | | Janet | Janet VM WASM worker | Yes | syntax | - | | Julia | Julia 1.3.0-DEV.560 legacy WASM worker | Yes | syntax | - | | Nim | Nim 2.2.4 WASM + clang/lld WASM | Yes | syntax | - | | Bash | GNU Bash WASIX / Wasmer SDK | Yes | syntax | - | | ClojureScript | cljs.js self-hosted compiler | Yes | syntax | - | | ReScript | ReScript 12.3.1 compiler (js_of_ocaml) | Yes | compiler diagnostics | - | | TinyGo | wasm-tinygo | Yes | syntax | - | | OCaml | wasm-of-js-of-ocaml / js_of_ocaml | Yes | syntax | - | | JavaScript | wasm-typescript / TypeScript service | Yes | TypeScript LSP | - | | TypeScript | wasm-typescript / TypeScript service | Yes | TypeScript LSP | - | | AssemblyScript | AssemblyScript compiler | Yes | AssemblyScript LSP | - | | WAT | WABT | Yes | WAT LSP | - | | WASM | Browser WebAssembly + WASI shim | Yes | syntax | - | | Lua | Wasmoon | Yes | syntax | - | | Fennel | fennel.lua on Wasmoon | Yes | syntax | - | | Zig | zig_small.wasm | Yes | syntax | - | | Scheme | Puppy Scheme / wasm-lisp | Yes | syntax | - | | Common Lisp | ECL 26.5.5 (Embeddable Common-Lisp) WASM | Yes | syntax | - | | Ruby | CRuby WASI | Yes | syntax | - | | Haskell | ghc-in-browser | Yes | syntax | - | | LFortran | LFortran LLVM evaluator (experimental) | Yes | compiler diagnostics | - | | Lean 4 | Lean 4.34.1 lean --run (Emscripten) | Yes | compiler diagnostics | - | | Fortran | f2c + @wasm-idle/llvm-core | Yes | Fortran LSP | - | | COBOL | GnuCOBOL 3.2 + @wasm-idle/llvm-core | Yes | syntax | - | | V | V 0.5.2 + @wasm-idle/llvm-core | Yes | syntax | - | | R | WebR | Yes | syntax | - | | Octave | wasm-octave | Yes | syntax | - | | DuckDB | DuckDB-Wasm | Files | DuckDB LSP | - | | SQLite | sql.js | n/a | syntax | - | | PostgreSQL | PostgreSQL 18 / PGlite | Files | syntax | - | | PHP | PHP 8.4 / php-wasm | Yes | syntax | - |

Browser LLDB debug runtime

Normal execution still compiles and instantiates the user module with the browser WebAssembly engine and the existing WASI host. C, C++, and wasm32-wasip1 Rust debug sessions use a separate, lazy-loaded path:

Monaco / debug UI
  ↕ DAP over a SharedArrayBuffer byte stream
LLDB worker (ProcessWasm + DWARF)
  ↕ GDB RSP over a separate SharedArrayBuffer byte stream
WAMR target worker (classic interpreter + source-debug stub)
  ↕
program.wasm + embedded DWARF + WASI

The compiler writes stable /workspace/... paths and embedded DWARF at -O0. The target is loaded before LLDB attaches; breakpoints and configurationDone are completed before WAMR starts the guest. Program output, input, lifecycle control, DAP, and RSP use separate logical streams. Breakpoints are retained per source path, so switching between C/C++ workspace files does not leak line numbers into another file and changes made while compilation is in flight are applied when the debug target connects. @wasm-idle/debug remains a code-only UI/adapter package, while @wasm-idle/llvm-core/debug owns the browser session and wasm-llvm owns the pinned LLDB/WAMR producers and binary manifests.

Debugging requires SharedArrayBuffer and a cross-origin-isolated deployment. Because verified runtime bytes are executed through Blob-backed ES modules and nested pthread Workers, the deployed Content Security Policy's script-src, worker-src, and connect-src must permit blob:. The LLDB and WAMR assets are not downloaded until a supported debug session starts. The bundled raw manifest is checked against its release receipt before parsing, and custom runtime locations must provide an explicit expected manifest SHA-256. The six executable assets are then streamed, bounded, and hash-verified exactly once before their owned bytes are transferred to the Workers. Workers do not re-fetch executable runtime URLs. Clean Pages builds fetch the exact pinned producer revision and manifest receipt through the shared release profile before the application build. The deployment refuses publication when any logical LLDB/WAMR asset is missing or mismatched after re-verifying raw or compressed logical bytes. If transactional publication cannot safely restore or identify an owned generation, its .wasm-debug.next-* and .wasm-debug.previous-* recovery artifacts are preserved for operator inspection. Later synchronization and the final Pages verifier fail closed until those artifacts (or a leftover .wasm-debug.sync.lock*) are manually inspected and resolved; they are never silently deleted or published. This build-time preparation does not change lazy browser loading: clients fetch the debugger payload only when a supported debug session starts. If the LLDB manifest is absent, invalid, or does not advertise the required breakpoint/step/stack/local capabilities, the playground labels that run as a trace fallback and keeps the existing instrumentation debugger available. LLDB-designated browser fixtures reject trace fallback, while a separate missing-asset fixture qualifies the pre-session trace alternative. Build and verify both producers using producer/lldb-browser and producer/wamr-browser, then assemble them with the Clang release:

Stable v1 is release-qualified on 64-bit desktop Chromium on Linux. It supports one active debug session for wasm32-wasi Preview 1 C/C++ and wasm32-wasip1 Rust artifacts produced by the pinned toolchains at -O0 with embedded DWARF. Debug starts a new, single-threaded WAMR classic interpreter instance; it does not attach to a browser-engine run or preserve that run's live state, and runtime-specific behavior can differ. Trace fallback is selected only before an LLDB session is established; an LLDB or WAMR failure ends that session instead of silently changing debugger semantics.

Stable v2 inherits that exact release boundary: 64-bit desktop Chromium on Linux, a cross-origin-isolated deployment, one active session, pinned C/C++ and wasm32-wasip1 Rust producer artifacts at -O0 with embedded DWARF, and a new WAMR debug execution rather than an attachment to an existing browser-engine run. DAP is an internal product protocol boundary; v2 does not claim compatibility with arbitrary third-party DAP clients or arbitrary externally produced Wasm/DWARF artifacts.

Pause is bounded but is not guaranteed to yield an inspectable stop while WAMR is blocked in a synchronous host call. In particular, a synchronous WAMR stdin read may time out instead of producing an inspectable pause. After that explicit timeout, Stop Debug still performs bounded Worker cleanup and permits a fresh debug execution; the session never remains indefinitely pending.

Stable v2 adds bounded variable-path watches and a paused-target memory inspector. Watch fallback accepts identifiers, nested fields, and non-negative indexes without enabling general expression evaluation. The memory panel can select a variable's DAP memoryReference, reads at most 256 bytes per request, pages by the selected byte count, renders hexadecimal/ASCII data and unreadable bytes as ??, and discards a response when the target resumes or the selected frame changes. While paused, it also accepts 1–256 two-digit hexadecimal bytes for a raw target-memory write and refreshes the displayed range after a successful write. This edits memory only; it does not provide typed setVariable semantics, validate that a value is safe for the guest, or preserve the mutation after restart. The complete UI write path is qualified in real Chromium with wasm32-wasi C/C++ and wasm32-wasip1 Rust programs. While paused, the same panel can install one session-scoped LLDB data breakpoint over a 1–256 byte memory range. The browser gate qualifies wasm32-wasi C write, C++ read/write, and wasm32-wasip1 Rust read access. Setting a new data breakpoint replaces the previous set, and Clear sends an empty replacement set to the target. Its opaque DAP data ID is never persisted across restart or a new debug execution. Because WAMR reports a completed memory access, the stopped source location can be the next executable line after the watched instruction. If a replacement or clear request times out, is rejected, or returns malformed DAP data, the debug execution stops and disposes both Workers so the UI cannot continue with an uncertain watchpoint set; Restart Debug then starts a clean execution. A successful but unverified replacement remains nonfatal and is reported as unverified. The Chromium qualification includes an indexed one-byte watched subrange that overlaps a four-byte scalar store. LLDB uses modify semantics for write mode: a write data breakpoint stops when at least one watched byte changes; a same-value store is reported by WAMR but automatically resumed by LLDB. Data breakpoints cover scalar classic-interpreter loads and stores only. Bulk-memory operations and host-side memory writes do not trigger data breakpoints; guest threads and memories outside the supported linear-memory configuration remain out of scope. Trace fallback does not advertise or emulate data breakpoints. The v2 Restart Debug action fully disposes the active LLDB and WAMR Workers, waits for the old execution to settle, and launches a fresh debug execution from the current workspace. It does not preserve target state or advertise the DAP restart capability.

Full expression evaluation, conditional/log breakpoints, typed variable mutation through DAP setVariable, DAP in-session restart, standalone terminate, optimized-debug guarantees, C++ exception support, STL pretty-printers, wasm64, guest threads, reverse debugging, SIMD, multi-module guests, and Rust WASI Preview 2/3 debugging remain outside the supported boundary.

cd ../wasm-llvm
WASM_LLVM_LLDB_ARTIFACT_DIR=/path/to/lldb-artifacts \
WASM_LLVM_WAMR_ARTIFACT_DIR=/path/to/wamr-artifacts \
pnpm prepare:clang-release

cd ../wasm-idle
WASM_RUST_PRODUCER_OUTPUT_ROOT=/path/to/rust-producer-output \
pnpm --dir runtimes/wasm-rust build:producer
pnpm sync:wasm-rust
pnpm sync:wasm-debug ../wasm-llvm/out/clang-browser
WASM_IDLE_BROWSER_SERVER_MODE=dev pnpm test:browser:debug:lldb

The synchronized manifest rejects missing hashes, incompatible Clang/LLDB revisions, and stale worker sidecars. The strict browser test covers real C, C++, and Rust breakpoint, step, output, and termination paths and rejects trace fallback or a missing debug asset. The Rust producer build is required for LLDB metadata; the historical split-runtime build intentionally lacks exact compiler provenance and is rejected instead of starting a potentially incompatible debugger.

Runtime details

Package/version base names the deployed static module or manifest and its producer package, or the browser-side package/workspace runtime that backs each row. Static ESM entries are page assets loaded over HTTP on demand, not files embedded in the published npm packages. Execution defaults / flags lists the default targets and flags wasm-idle applies, plus the public per-run options that change execution. Customization lists the SDK's explicit runtimeAssets fields and the matching PUBLIC_WASM_* variables understood by this repository's example page. Published packages do not read environment variables or import SvelteKit modules.

| Language / IDs | Package/version base | Execution defaults / flags | Customization | | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | GolfScriptGOLFSCRIPT | darrenks/golfscript cded5425 (upstream MIT notice), original Ruby source on the bundled Ruby/WASI VM | Loads the unchanged GolfScript CLI in a fresh Ruby VM; supports stack operations, arrays, blocks, arbitrary integers, Ruby string interpolation and original -q/-n/-r options; reads stdin to EOF, or accepts argument-array input after --, with original implicit final output | runtimeAssets.golfscript.interpreterUrl, runtimeAssets.rootUrl, runtimeAssets.ruby, stdin, programArgs, activePath, workspaceFiles; code-pinned original script, readonly source files, execution limits and cancellation; prepare initializes Ruby without running GolfScript source | | APECodeAPECODE | seo-rii/apecode 0.1.0 (c7ae98d3), original pure Python wheel on Pyodide; upstream has no declared standalone license | Runs the original parser and state-machine interpreter through run_source; reads numeric test cases to EOF, models rock weights, grippers and built-in states, and writes original result/trace bytes through Python file descriptors; each run creates fresh interpreter state | runtimeAssets.apecode.baseUrl, runtimeAssets.rootUrl, stdin, activePath, workspaceFiles; code-pinned local wheel; execution timeout, output and workspace limits plus cancellation; prepare loads the interpreter without parsing or running user source | | LOLCODE 1.3LOLCODE | justinmeza/lci v1.3 (GPL-3.0-or-later), wasi-sdk 33.0 build | Runs the unchanged lci lexer, parser and interpreter for LOLCODE 1.3, including functions, loops, arrays, type casts and Unicode string escapes; GIMMEH reads a line and VISIBLE normally adds a newline; each run starts with fresh state | runtimeAssets.rootUrl, stdin, activePath, workspaceFiles; fixed interpreter argv; prepare compiles the runtime without executing or validating the source | | UHMLANG (엄준식)UHMLANG | rycont/umjunsik-lang e973f9d2 (MIT), Go 1.25.3 WASI build | Runs the original Go lexer, parser and evaluator with signed 64-bit arithmetic, variables, jumps and conditional statements; numeric stdin is line based and character output writes Unicode code points; each execution starts with fresh state | runtimeAssets.rootUrl, stdin, activePath, workspaceFiles; fixed interpreter argv; prepare compiles the runtime without executing or validating the source | | AheuiAHEUI | aheui/rpaheui 1.2.5 (BSD-2-Clause) on Pyodide 314.0.7; one receipt-verified pure Python wheel | Runs the original rpaheui compiler and interpreter with --no-c --warning-limit=0, 26 stacks, a queue and a port, with Unicode character/integer stdin; normal halt returns its stack value; no handwritten parser or subset executor | runtimeAssets.rootUrl, runtimeAssets.aheui.baseUrl, stdin, activePath, workspaceFiles; fixed interpreter argv; prepare loads the interpreter without executing source | | MalbolgeMALBOLGE | Original Ben Olmstead interpreter, TryItOnline/malbolge b0869870 (public domain), compiled with WASI SDK 33 | Runs the original 59049-cell ternary and self-modifying interpreter; source-file input is separate from byte stdin/stdout; EOF stores 59048; requires at least two non-whitespace source bytes | runtimeAssets.rootUrl, stdin, activePath, workspaceFiles; fixed interpreter argv; prepare compiles the runtime without executing or validating the source | | WhitespaceWHITESPACE | koturn/Whitespace 22a57aab (MIT), compiled with WASI SDK 33 | Runs the upstream Whitespace 0.3 interpreter with a documented divisor-guard correction, copy/slide, heap, labels, calls and signed 32-bit integers; character/numeric stdin and exact stdout; character EOF is -1; source limit 65535 UTF-8 bytes | runtimeAssets.rootUrl, stdin, activePath, workspaceFiles; fixed interpreter argv; prepare compiles the runtime without executing or validating the source | | C3C3 | wasm-llvm/c3-browser: C3 0.8.3 / LLVM 22.1.8 | Verified c3c and builtin LLD compile real C3 in a fresh browser Worker; UTF-8 env.readByte/env.writeByte ABI and exported main; std::io and WASI unavailable | runtimeAssets.c3.baseUrl, stdin, activePath, workspaceFiles; fixed compiler flags and bounded Wasm memories | | CC | @wasm-idle/[email protected] / Clang 22.1.8 WASI sysroot from the wasm-llvm producer | clang for wasm32-wasi; default -std=gnu11; LLDB mode compiles untouched source with embedded DWARF at -g -O0 and runs it in WAMR; normal runs still use the browser WASI host; supports stdin and programArgs | runtimeAssets.clang.baseUrl/loader or rootUrl; compileArgs, programArgs, cVersion, activePath, workspaceFiles, debugMode, breakpoints, pauseOnEntry | | C++CPP | @wasm-idle/[email protected] / Clang 22.1.8 WASI sysroot from the wasm-llvm producer | clang++ for wasm32-wasi; default -std=gnu++20; LLDB mode compiles untouched source with embedded DWARF at -g -O0 and runs it in WAMR; normal runs still use the browser WASI host; supports stdin and programArgs | runtimeAssets.clang.baseUrl/loader or rootUrl; compileArgs, programArgs, cppVersion, activePath, workspaceFiles, debugMode, breakpoints, pauseOnEntry | | Objective-COBJC | GNUstep libobjc2 v2.3 assets from the wasm-llvm producer + @wasm-idle/[email protected] | clang -x objective-c -fobjc-runtime=gnustep-2.0 -fblocks for wasm32-wasi; links libobjc.a, libgnustep-base.a, and libffi.a when Foundation is imported; Foundation headers are inlined from foundation-headers.json; includes a constructor wrapper for Objective-C class registration; auto-compiles .m/.mm/.c workspace files; trace debug instruments active source and uses wasm-idle controls; supports stdin and programArgs; large Objective-C assets may be served as gzip-only .gz files through the service worker or worker fallback | runtimeAssets.objectivec.baseUrl/libobjcUrl/headersUrl/libgnustepBaseUrl/libgnustepBaseObjectUrl/foundationHeadersUrl/libffiUrl or PUBLIC_WASM_OBJECTIVEC_*; runtimeAssets.clang.baseUrl/loader for the clang toolchain; activePath, workspaceFiles, compileArgs, debug, breakpoints, pauseOnEntry | | Objective-C++OBJECTIVECXX | Same GNUstep libobjc2 v2.3 + libc++ assets as Objective-C from the wasm-llvm producer + @wasm-idle/[email protected]; no extra compiler assets | clang -x objective-c++ -std=gnu++20 -fobjc-runtime=gnustep-2.0 -fblocks for wasm32-wasi with libc++ headers; active file defaults to main.mm; links libobjc.a (plus GNUstep Base and libffi.a when Foundation is imported); auto-compiles .mm/.m/.c workspace files; supports stdin and programArgs; trace debugging is not supported | Shares runtimeAssets.objectivec and runtimeAssets.clang with Objective-C; activePath, workspaceFiles, compileArgs, programArgs | | PythonPYTHON3 | static ESM static/pyodide/pyodide.mjs / [email protected] | loads pyodide.mjs, pyodide.asm.mjs, pyodide.asm.wasm, and python_stdlib.zip from the configured static asset tree on demand; supports stdin, workspace files, and trace debugging | runtimeAssets.python.baseUrl/loader or rootUrl; stdin, activePath, workspaceFiles, debug, breakpoints, pauseOnEntry, debugPath | | Befunge-93BEFUNGE93 | catseye/Befunge-93 8fe4065c (BSD-3-Clause), compiled with WASI SDK 33 | Runs the original interpreter with an 80 by 25 wrapping playfield, signed 32-bit stack, string mode and self-modifying p/g instructions; character and integer stdin share the WASI terminal; character EOF is -1 | runtimeAssets.rootUrl, stdin, activePath, workspaceFiles; fixed quiet argv; prepare compiles the runtime without executing or validating the source | | BrainfuckBRAINFUCK | susam/bfc b1b92fc (MIT), compiled with WASI SDK 33 | Runs the pinned upstream interpreter in a browser Worker with a fresh read-only source filesystem; 30000 wrapping 8-bit cells, UTF-8 byte stdin/stdout, EOF sets the cell to zero | runtimeAssets.rootUrl, stdin, activePath, workspaceFiles; fixed interpreter argv; prepare compiles the runtime without executing or validating the source | | HyHY | Hy 1.3.1 + funcparserlib 1.0.1 pure-Python wheels on [email protected] | receipt-verifies the bundled wheels, unpacks them into Pyodide site-packages, and compiles Hy with hy.compiler.hy_compile; (input)/(print) share the Python stdin/stdout bridge; no debugger or automatic package loading | runtimeAssets.hy.baseUrl or PUBLIC_WASM_HY_BASE_URL plus the Python runtime assets; stdin, activePath | | JavaJAVA | @wasm-idle/[email protected] / TeaVM compiler assets | compiler.wasm compiles Java to browser WASM/JS; supports stdin and programArgs | runtimeAssets.java.baseUrl/loader or rootUrl | | RustRUST | [email protected] / rust-1.99.0-browser-integrated-v1 + integrated LLVM/LLD 22.1.8 from the wasm-llvm producer; exact rustc/LLVM provenance is recorded for LLDB compatibility | browser host wasm32-wasip1-threads; default target wasm32-wasip1, selectable wasm32-wasip1, wasm32-wasip2, wasm32-wasip3; LLDB mode is currently limited to wasm32-wasip1 and emits embedded DWARF with -C debuginfo=2 -C opt-level=0; normal Preview 1/2/3 execution remains unchanged; supports stdin and programArgs | runtimeAssets.rust.compilerUrl, runtimeAssets.rust.debugModuleUrl, or PUBLIC_WASM_RUST_COMPILER_URL; rootUrl, rustTargetTriple, programArgs, debugMode; compiler requests accept edition, crateType, extendedTimeout, log, and onProgress; runtime manifest controls compiler memory, timeout, and shared workspace size | | GoGO | [email protected] / go1.26.1 | default target wasip1/wasm; selectable wasip1/wasm, wasip2/wasm, wasip3/wasm, js/wasm; supports stdin and programArgs | runtimeAssets.go.compilerUrl or PUBLIC_WASM_GO_COMPILER_URL; goTarget, programArgs | | DD | [email protected] / ldc-1.42.0-wasi-smoke | ldc2 -conf=/toolchain/etc/ldc2.conf -mtriple=wasm32-wasi -c then wasm-ld to WASI preview1; supports stdin and programArgs | runtimeAssets.d.moduleUrl or PUBLIC_WASM_D_MODULE_URL; activePath, programArgs | | C#CSHARP | [email protected] / .NET 9.0.16 browser-wasm / Roslyn C# 4.14.0 | CSharpCompilationOptions(OutputKind.ConsoleApplication); concurrentBuild=false; target browser-wasm; language-specific AOT bundle runtime/csharp/; supports stdin and programArgs | runtimeAssets.dotnet.moduleUrl or PUBLIC_WASM_DOTNET_MODULE_URL; programArgs, LSP on/off | | F#FSHARP | [email protected] / .NET 9.0.16 browser-wasm / FCS 43.12.204 / FSharp.Core 10.1.204 | fsc.exe --target:exe --targetprofile:netcore --noframework --simpleresolution --nowin32manifest --debug- --optimize-; language-specific AOT bundle runtime/fsharp/; supports stdin and programArgs | runtimeAssets.dotnet.moduleUrl or PUBLIC_WASM_DOTNET_MODULE_URL; programArgs, LSP on/off | | VB.NETVBNET | [email protected] / .NET 9.0.16 browser-wasm / Roslyn Visual Basic 4.14.0 | VisualBasicCompilationOptions(OutputKind.ConsoleApplication); concurrentBuild=false, OptionStrict=Off, OptionInfer=On, OptionExplicit=On; target browser-wasm; language-specific AOT bundle runtime/vbnet/; supports stdin and programArgs | runtimeAssets.dotnet.moduleUrl or PUBLIC_WASM_DOTNET_MODULE_URL; programArgs, LSP on/off | | ElixirELIXIR | wasm-elixir asset bundle / @swmansion/[email protected] | Popcorn/AtomVM bundle bundle.avm; supports stdin | runtimeAssets.elixir.bundleUrl or PUBLIC_WASM_ELIXIR_BUNDLE_URL | | ErlangERLANG | wasm-elixir asset bundle / @swmansion/[email protected] | Popcorn/AtomVM bundle bundle.avm; supports stdin | runtimeAssets.erlang.bundleUrl or PUBLIC_WASM_ERLANG_BUNDLE_URL; falls back to Elixir bundle URL | | PrologPROLOG | [email protected] synced into static/wasm-prolog | static worker runs SWI-Prolog; supports stdin and programArgs | runtimeAssets.prolog.baseUrl/runtimeAssets.prolog.workerUrl or PUBLIC_WASM_PROLOG_BASE_URL/PUBLIC_WASM_PROLOG_WORKER_URL; programArgs, activePath, workspaceFiles | | GleamGLEAM | @live-codes/[email protected] static worker | Gleam worker compiles/runs browser output with source manifest; supports stdin | runtimeAssets.gleam.baseUrl/workerUrl/manifestUrl or PUBLIC_WASM_GLEAM_*; programArgs, workspaceFiles | | GrainGRAIN | grain-lang/grain v0.7.2 release: upstream js_of_ocaml grainc.bc.js + @grain/stdlib 0.7.2 (precompiled .gro) | Verified upstream grainc compiles .gr workspace files to WASI in a fresh browser Worker; stdio-only WASI host with streaming stdin | runtimeAssets.grain.baseUrl or PUBLIC_WASM_GRAIN_BASE_URL; stdin, programArgs, activePath, workspaceFiles; Wasm memory bounded by limits.maxWasmMemoryBytes | | PerlPERL | WebPerl v0.09-beta (webperl_prebuilt_v0.09-beta.zip) | host-verifies the manifest, stored assets, logical hashes, and profile-bound one-shot runner before executing emperl; supports stdin and programArgs | explicit runtimeAssets.perl.baseUrl/workerUrl/manifestUrl overrides require one complete profile-and-runner receipt bundle; URL-only PUBLIC_WASM_PERL_* overrides fail closed; programArgs, activePath, workspaceFiles | | TclTCL | Wacl Tcl 2017-05-29 (wacl.zip) | host-verifies the manifest, stored assets, logical hashes, and profile-bound one-shot runner before executing Wacl Tcl; supports stdin and programArgs | bundled mirrors may set runtimeAssets.tcl.baseUrl/workerUrl/manifestUrl or PUBLIC_WASM_TCL_BASE_URL/PUBLIC_WASM_TCL_WORKER_URL; custom executable bytes require one complete profile-and-runner receipt bundle; programArgs, activePath, workspaceFiles | | AWKAWK | GoAWK v1.31.0 / go1.25.3 | static worker runs goawk.wasm; supports stdin and programArgs | runtimeAssets.awk.baseUrl/runtimeAssets.awk.workerUrl or PUBLIC_WASM_AWK_BASE_URL/PUBLIC_WASM_AWK_WORKER_URL; programArgs, activePath, workspaceFiles | | PascalPASCAL | pas2js 3.2.1 (9ac46614dc82) | static worker compiles with pas2js then runs JS; supports stdin | runtimeAssets.pascal.baseUrl/runtimeAssets.pascal.workerUrl or PUBLIC_WASM_PASCAL_BASE_URL/PUBLIC_WASM_PASCAL_WORKER_URL; programArgs, activePath, workspaceFiles | | ForthFORTH | [email protected] / static worker | WAForth worker; supports stdin and programArgs | runtimeAssets.forth.baseUrl/runtimeAssets.forth.workerUrl or PUBLIC_WASM_FORTH_BASE_URL/PUBLIC_WASM_FORTH_WORKER_URL; programArgs, activePath, workspaceFiles | | JJ | jsoftware-j-playground static worker | J playground worker; supports stdin and programArgs | runtimeAssets.j.baseUrl/runtimeAssets.j.workerUrl or PUBLIC_WASM_J_BASE_URL/PUBLIC_WASM_J_WORKER_URL; programArgs, activePath, workspaceFiles | | BQNBQN | CBQN static worker / Emscripten 3.1.8 | CBQN worker; supports stdin and programArgs | runtimeAssets.bqn.baseUrl/runtimeAssets.bqn.workerUrl or PUBLIC_WASM_BQN_BASE_URL/PUBLIC_WASM_BQN_WORKER_URL; programArgs, activePath, workspaceFiles | | JanetJANET | Janet 1.41.3-dev / Emscripten 3.1.8 opaque vendored bundle | host-verifies the manifest, stored assets, logical hashes, and profile-bound one-shot runner before executing the Janet VM; supports stdin and programArgs | explicit runtimeAssets.janet.baseUrl/workerUrl/manifestUrl overrides require one complete profile-and-runner receipt bundle; URL-only PUBLIC_WASM_JANET_* overrides fail closed; programArgs, activePath, workspaceFiles | | JuliaJULIA | @chriskoch/[email protected] | host-verifies the manifest, stored assets, logical hashes, and profile-bound one-shot runner before executing the legacy Julia VM; supports stdin and activePath | explicit runtimeAssets.julia.baseUrl/workerUrl/manifestUrl overrides require one complete profile-and-runner receipt bundle; URL-only PUBLIC_WASM_JULIA_* overrides fail closed; activePath | | NimNIM | Nim 2.2.4 / benagastov Nim-WASM-Compiler with clang/lld WASM | host-verifies the manifest, eight stored assets, logical hashes, and profile-bound one-shot runner before compiling Nim to C and linking with clang/lld WASM in a disposable worker; supports stdin, programArgs, and activePath | explicit runtimeAssets.nim.baseUrl/workerUrl/manifestUrl overrides require one complete profile-and-runner receipt bundle; URL-only PUBLIC_WASM_NIM_* overrides fail closed; programArgs, activePath | | BashBASH | @wasm-idle/[email protected] / GNU Bash WASIX + receipt-pinned @wasmer/[email protected] profile | host-verifies one profile manifest, the stored SDK JavaScript, Wasmer Wasm, and WEBc before starting a fixed worker generation with no runtime-asset fetches; invokes bash -c <code> <activePath> ...programArgs and supports stdin, programArgs, activePath, and workspaceFiles | rootUrl mirrors reuse the bundled profile; explicit runtimeAssets.bash.baseUrl/manifestUrl/moduleUrl/wasmerWasmUrl/webcUrl overrides require one complete profile; workerUrl is rejected; stdin, programArgs, activePath, workspaceFiles | | ClojureScriptCLOJURESCRIPT | @wasm-idle/[email protected] / ClojureScript 1.12.134 | static worker compiles and evaluates with the official cljs.js self-hosted compiler; supports stdin, programArgs, activePath, and workspaceFiles | runtimeAssets.clojurescript.baseUrl/runtimeAssets.clojurescript.workerUrl or PUBLIC_WASM_CLOJURESCRIPT_BASE_URL/PUBLIC_WASM_CLOJURESCRIPT_WORKER_URL; programArgs, activePath, workspaceFiles | | ReScriptRESCRIPT | upstream ReScript 12.3.1