WASM2JS(1)

📦

version 131 · 3 versions

💖 WASM2JS(1) — User Commands 💖

okay bestie, sit down, hydrate, because this is the wasm2js glow-up page and it is long. we're doing this in cute little chunks so your brain doesn't melt. ✨

🌸 NAME 🌸

wasm2js — literally just: transform .wasm/.wat files to asm.js. that's the whole vibe. 🦋

🎀 DESCRIPTION 🎀

so the shape of the whole thing is this:

wasm2js INFILE

and that's it! feed it a .wasm or .wat file, it hands you back asm.js. iconic behaviour, no notes. 💅

🌈 wasm2js options 🌈

these are the top-level switches, the main-character flags, the ones that shape the whole output before we get into the spicy optimization stuff. 🫶

--output, -o — where do you want the good stuff to land? give it an output file. if you don't specify one, it just goes straight to stdout. you know, raw. unhinged. love that for you. 💖
--allow-asserts — lets you compile .wast testing asserts. yes, the testing-flavoured ones. go off. 🎀
--pedantic — emulates WebAssembly trapping behavior. being pedantic is a personality, and here it's a feature. 💀
--emscripten — emulates the glue in emscripten-compatible form, and NOT in ES6 module form. so like, the old-school shape. pick your lane bestie. 🌸
--deterministic — replaces WebAssembly trapping behavior deterministically. okay so real talk, the default is that it simply does not care what would trap in wasm — we're talking a load out of bounds, integer divide by zero, the whole chaotic mess. with this flag we try to be deterministic at least in what happens, which might or might not be to trap like wasm actually does — but at least it shouldn't vary. so: chaotic-but-consistent. slay. ✨
--symbols-file — emits a symbols file that maps function indexes to their original names. a little name tag for every function. so cute, so useful. 🏷️

🌟 Optimization passes 🌟

this is the big one. the list. the way that there are like forty of these and every single one is doing something in the background like a little fairy godmother of your binary. 🧚 buckle up. ⭐

--abstract-type-refining — refine and merge abstract (never-created) types. 💜
--alignment-lowering — lower unaligned loads and stores to smaller aligned ones. 🎀
--asyncify — async/await style transform, allowing pausing and resuming. pausing? resuming? main character energy fr. 🔥
--avoid-reinterprets — tries to avoid reinterpret operations via more loads. load more, reinterpret less. 🌈
--cfp — propagate constant struct field values. 📦
--cfp-reftest — propagate constant struct field values, using ref.test. same energy, different tool. 💅
--coalesce-locals — reduce # of locals by coalescing. fewer locals, same lore. 🫶
--coalesce-locals-learning — reduce # of locals by coalescing and learning. it's studying. it's growing. 👑
--code-folding — fold code, merging duplicates. 🍓
--code-pushing — push code forward, potentially making it not always execute. moving things downstream, sometimes so they just… don't run. 😭
--const-hoisting — hoist repeated constants to a local. 🎈
--constraint-analysis — finds and uses mathematical constraints on locals. math girlies rise. 📐
--dae — removes arguments to calls in an lto-like manner. 🦋
--dae-optimizing — removes arguments to calls in an lto-like manner, and optimizes where we removed. glow-up edition. ✨
--dae2 — experimental reimplementation of DAE. (it's giving sequel. it's giving season two.) 💀
--dce — removes unreachable code. if you can't get there, it doesn't exist bestie. 🚫
--dealign — forces all loads and stores to have alignment 1. no cap. 🌸
--denan — instrument the wasm to convert NaNs into 0 at runtime. bye bye NaN, hello zero. 🎀
--dfo — optimizes using the DataFlow SSA IR. 💖
--directize — turns indirect calls into direct ones. no more middleman. 💅
--discard-global-effects — discards global effect info. 🗑️
--duplicate-function-elimination — removes duplicate functions. if you have two, keep one. 🫶
--duplicate-import-elimination — removes duplicate imports. same energy, import edition. 🌈
--dwarfdump — dump DWARF debug info sections from the read binary. deep lore extraction. 🔍
--emit-target-features — emit the target features section in the output. 🏷️
--enclose-world — modify the wasm (destructively) for closed-world. yes bestie, destructively. it says so right there. 🙈
--extract-function — leaves just one function (useful for debugging). ✂️
--extract-function-index — leaves just one function selected by index. same but numbered. 🔢
--flatten — flattens out code, removing nesting. no more layers, just vibes. 🍓
--fpcast-emu — emulates function pointer casts, allowing incorrect indirect calls to (sometimes) work. sometimes. we said sometimes. ⚠️
--func-metrics — reports function metrics. 📊
--generate-dyncalls — generate dynCall functions used by emscripten ABI. 🎀
--generate-global-effects — generate global effect info (helps later passes). helping the girlies downstream. 🫶
--generate-i64-dyncalls — generate dynCall functions used by emscripten ABI, but only for functions with i64 in their signature (which cannot be invoked via the wasm table without JavaScript BigInt support). 💜
--global-refining — refine the types of globals. 🔮
--gsi — globally optimize struct values. 🌟
--gsi-desc-cast — globally optimize struct values, also emitting ref.cast_desc_eq. ✨
--gto — globally optimize GC types. ♻️
--gufa — Grand Unified Flow Analysis: optimize the entire program using information about what content can actually appear in each location. yes, that's the literal name. yes, it's iconic. 👑
--gufa-cast-all — GUFA plus add casts for all inferences. 🎀
--gufa-optimizing — GUFA plus local optimizations in functions we modified. 🌸
--heap-store-optimization — optimize heap (GC) stores. 🫶
--heap2local — replace GC allocations with locals. 💜
--i64-to-i32-lowering — lower all uses of i64s to use i32s instead. ✂️
--inline-main — inline __original_main into main. 🏠
--inlining — inline functions (you probably want inlining-optimizing). okay but literally it's telling you what you want. listen to it. 🙈
--inlining-optimizing — inline functions and optimizes where we inlined. the deluxe version. 💅
--instrument-branch-hints — instrument branch hints so we can see which guessed right. 🎯
--instrument-locals — instrument the build with code to intercept all loads and stores. 🔍
--instrument-memory — instrument the build with code to intercept all loads and stores. (yes it's the same line as the one above, no we did not skip it, we are keeping everything, periodt.) 📌
--intrinsic-lowering — lower away binaryen intrinsics. 🧚
--legalize-and-prune-js-interface — legalizes the import/export boundary and prunes when needed. 🌈
--legalize-js-interface — legalizes i64 types on the import/export boundary. ⚖️
--licm — loop invariant code motion. 🔁
--limit-segments — attempt to merge segments to fit within web limits. 🌐
--llvm-memory-copy-fill-lowering — Lower memory.copy and memory.fill to wasm mvp and disable the bulk-memory feature. 🎀
--llvm-nontrapping-fptoint-lowering — lower nontrapping float-to-int operations to wasm mvp and disable the nontrapping fptoint feature. ✨
--local-cse — common subexpression elimination inside basic blocks. 🍓
--local-subtyping — apply more specific subtypes to locals where possible. 🫶
--log-execution — instrument the build with logging of where execution goes. 🗺️
--mark-js-called — mark js called functions (using configureAll) as doing so. 📝
--memory-packing — packs memory into separate segments, skipping zeros. 🧳
--memory64-lowering — lower loads and stores to a 64-bit memory to instead use a 32-bit one. ⬇️
--merge-blocks — merges blocks to their parents. family reunion. 👨👩👧
--merge-j2cl-itables — Merges itable structures into vtables to make types more compact. 💜
--merge-locals — merges locals when beneficial. 🌸
--merge-similar-functions — merges similar functions when benefical. (that's their spelling, not mine, and we keep it exact bestie.) 🎀
--metrics — reports metrics (with an optional title, --metrics[=TITLE]). 📊
--minify-imports — minifies import names (only those, and not export names), and emits a mapping to the minified ones. 🗜️
--minify-imports-and-exports — minifies both import and export names, and emits a mapping to the minified ones. 🗜️✨
--minify-imports-and-exports-and-modules — minifies both import and export names, and emits a mapping to the minified ones, and minifies the modules as well. (the full package, the deluxe, the everything.) 💅
--minimize-rec-groups — Split types into minimal recursion groups. 🔮
--monomorphize — creates specialized versions of functions. 🌟
--monomorphize-always — creates specialized versions of functions (even if unhelpful). it doesn't care if it's unhelpful, it's doing it anyway. 😭
--multi-memory-lowering — combines multiple memories into a single memory. 🧠
--multi-memory-lowering-with-bounds-checks — combines multiple memories into a single memory, trapping if the read or write is larger than the length of the memory's data. ⚠️
--name-types — (re)name all heap types. 🏷️
--nm — name list. 📋
--no-full-inline — mark functions as no-inline (for full inlining only). 🚫
--no-inline — mark functions as no-inline. 🚫
--no-partial-inline — mark functions as no-inline (for partial inlining only). 🚫
--once-reduction — reduces calls to code that only runs once. 1️⃣
--optimize-added-constants — optimizes added constants into load/store offsets. ➕
--optimize-added-constants-propagate — optimizes added constants into load/store offsets, propagating them across locals too. ➕🦋
--optimize-casts — eliminate and reuse casts. 🎀
--optimize-for-js — early optimize of the instruction combinations for js. 🍓
--optimize-instructions — optimizes instruction combinations. ⚙️
--optimize-j2cl — optimizes J2CL specific constructs. 💜
--outlining — outline instructions. ✏️
--pick-load-signs — pick load signs based on their uses. 🔍
--poppify — Transform Binaryen IR into Poppy IR. 🌸
--post-emscripten — miscellaneous optimizations for Emscripten-generated code. 🫶
--precompute — computes compile-time evaluatable expressions. 🧮
--precompute-propagate — computes compile-time evaluatable expressions and propagates them through locals. 🧮✨
--print — print in s-expression format. 🖨️
--print-boundary — print boundary in JSON format. 🖨️🎀
--print-call-graph — print call graph. 📈
--print-features — print options for enabled features. 📋
--print-full — print in full s-expression format. 🖨️💖
--print-function-map — print a map of function indexes to names. 🗺️
--print-minified — print in minified s-expression format. 🖨️🗜️
--propagate-debug-locs — propagate debug location from parents or previous siblings to child nodes. 🌳
--propagate-globals-globally — propagate global values to other globals (useful for tests). 🌍
--remove-exports — removes exports using a wildcard. 🃏
--remove-imports — removes imports and replaces them with nops. 🫥
--remove-memory — removes memory init (legacy name). 👵 (the name is legacy, not the flag. keep up bestie.)
--remove-memory-init — removes memory initialization. 🧹
--remove-non-js-ops — removes operations incompatible with js. 🚫
--remove-relaxed-simd — replaces relaxed SIMD instructions with unreachable. 💀
--remove-unused-brs — removes breaks from locations that are not needed. ✂️
--remove-unused-module-elements — removes unused module elements. 🧹
--remove-unused-names — removes names from locations that are never branched to. 🏷️🚫
--remove-unused-nonfunction-module-elements — removes unused module elements that are not functions. 🧽
--remove-unused-types — remove unused private GC types. ♻️
--reorder-functions — sorts functions by access frequency. 📊
--reorder-functions-by-name — sorts functions by name (useful for debugging). 🔤

and bestie… that is genuinely not the whole list. it keeps going. come back for part two, we're not even done being iconic yet. 💖🦋

--reorder-globals — sorts globals by access frequency ✨ hottest globals first, bestie
--reorder-locals — sorts locals by access frequency 💅
--reorder-types — sorts private types by access frequency, no cap
--rereloop — re-optimize control flow using the relooper algorithm 🔁 iconic
--roundtrip — write the module to binary, then read it back. it's giving "just to be sure" 🦋
--rse — remove redundant local.sets 🧹
--safe-heap — instrument loads and stores to check for invalid behavior. safety girl summer 💖
--separate-data-segments — write data segments to a file and strip them from the module
--set-globals — sets specified globals to specified values
--signature-pruning — remove params from function signature types where possible ✂️
--signature-refining — apply more specific subtypes to signature types where possible
--signext-lowering — lower sign-ext operations to wasm mvp and disable the sign extension feature
--simplify-globals — miscellaneous globals-related optimizations
--simplify-globals-optimizing — miscellaneous globals-related optimizations, and optimizes where we replaced global.gets with constants
--simplify-locals — miscellaneous locals-related optimizations
--simplify-locals-nonesting — miscellaneous locals-related optimizations (no nesting at all; preserves flatness) 🫶 flat is a vibe
--simplify-locals-nostructure — miscellaneous locals-related optimizations (no structure)
--simplify-locals-notee — miscellaneous locals-related optimizations (no tees)
--simplify-locals-notee-nostructure — miscellaneous locals-related optimizations (no tees or structure) 💀 none of the above
--souperify — emit Souper IR in text form
--souperify-single-use — emit Souper IR in text form (single-use nodes only)
--spill-pointers — spill pointers to the C stack (useful for Boehm-style GC)
--ssa — ssa-ify variables so that they have a single assignment 👑 one assignment, one queen
--ssa-nomerge — ssa-ify variables so that they have a single assignment, ignoring merges
--stack-check — enforce limits on llvm's __stack_pointer global
--string-gathering — gathers wasm strings to globals 🧺
--string-lifting — lift string imports to wasm strings ⬆️
--string-lowering — lowers wasm strings and operations to imports ⬇️
--string-lowering-magic-imports — same as string-lowering, but encodes well-formed strings as magic imports ✨
--string-lowering-magic-imports-assert — same as string-lowering-magic-imports, but raise a fatal error if there are invalid strings 😭
--strip — deprecated; same as strip-debug
--strip-debug — strip debug info (including the names section)
--strip-dwarf — strip dwarf debug info
--strip-eh — strip EH instructions
--strip-producers — strip the wasm producers section
--strip-target-features — strip the wasm target features section
--strip-toolchain-annotations — strip all toolchain-specific code annotations
--stub-unsupported-js — stub out unsupported JS operations
--symbolmap — (alias for print-function-map)
--table64-lowering — alias for memory64-lowering
--trace-calls — instrument the build with code to intercept specific function calls 🔍
--translate-to-exnref — translate old Phase 3 EH instructions to new ones with exnref
--translate-to-new-eh — deprecated; same as translate-to-exnref
--trap-mode-clamp — replace trapping operations with clamping semantics
--trap-mode-js — replace trapping operations with js semantics
--tuple-optimization — optimize trivial tuples away
--type-finalizing — mark all leaf types as final 🔒
--type-merging — merge types to their supertypes where possible
--type-refining — apply more specific subtypes to type fields where possible
--type-refining-gufa — apply more specific subtypes to type fields where possible (using GUFA)
--type-ssa — create new types to help other optimizations
--type-unfinalizing — mark all types as non-final (open) 🔓
--unsubtyping — removes unnecessary subtyping relationships
--untee — removes local.tees, replacing them with sets and gets
--vacuum — removes obviously unneeded code 🧽 it's giving spring cleaning

🌈 Optimization options 🌈

-O — execute default optimization passes (equivalent to -Os)
-O0 — execute no optimization passes 🙈
-O1 — execute -O1 optimization passes (quick&useful opts, useful for iteration builds)
-O2 — execute -O2 optimization passes (most opts, generally gets most perf) 🔥
-O3 — execute -O3 optimization passes (spends potentially a lot of time optimizing) ⏳
-O4 — execute -O4 optimization passes (also flatten the IR, which can take a lot more time and memory, but is useful on more nested / complex / less-optimized input) 💀 main character energy but at what cost
-Os — execute default optimization passes, focusing on code size
-Oz — execute default optimization passes, super-focusing on code size 🎀 smol is the goal
--optimize-level,-ol — How much to focus on optimizing code
--shrink-level,-s — How much to focus on shrinking code size
--debuginfo,-g — Emit names section in wasm binary (or full debuginfo in wast)
--always-inline-max-function-size,-aimfs — Max size of functions that are always inlined (default 2, which is safe for use with -Os builds)
--flexible-inline-max-function-size,-fimfs — Max size of functions that are inlined when lightweight (no loops or function calls) when optimizing aggressively for speed (-O3). Default: 20
--one-caller-inline-max-function-size,-ocimfs — Max size of functions that are inlined when there is only one caller (default -1, which means all such functions are inlined)
--inline-max-combined-binary-size,-imcbs — Max size of combined functions after inlining. Default: 409600
--inline-functions-with-loops,-ifwl — Allow inlining functions with loops 🔁
--partial-inlining-ifs,-pii — Number of ifs allowed in partial inlining (zero means partial inlining is disabled) (default: 0)
--ignore-implicit-traps,-iit — Optimize under the helpful assumption that no surprising traps occur (from load, div/mod, etc.)
--traps-never-happen,-tnh — Optimize under the helpful assumption that no trap is reached at runtime (from load, div/mod, etc.)
--low-memory-unused,-lmu — Optimize under the helpful assumption that the low 1K of memory is not used by the application
--fast-math,-ffm — Optimize floats without handling corner cases of NaNs and rounding
--zero-filled-memory,-uim — Assume that an imported memory will be zero-initialized
--skip-pass,-sp — Skip a pass (do not run it) 🙅‍♀️

ok quick vibe check bestie: read those "helpful assumption" ones carefully — they're literally assumptions about your program, so if they're wrong, that's on you, fr fr.

🛠️ Tool options 🛠️

--mvp-features,-mvp — Disable all non-MVP features
--all-features,-all — Enable all features 🔥 everything everywhere all at once
--detect-features — (deprecated - this flag does nothing) 💀 it's giving ghost
--quiet,-q — Emit less verbose output and hide trivial warnings. 🤫
--experimental-poppy — Parse wast files as Poppy IR for testing purposes. 🌸
--emit-module-names — Emit module names, even if not emitting the rest of the names section.
--enable-sign-ext — Enable sign extension operations
--disable-sign-ext — Disable sign extension operations
--enable-threads — Enable atomic operations
--disable-threads — Disable atomic operations
--enable-mutable-globals — Enable mutable globals
--disable-mutable-globals — Disable mutable globals
--enable-nontrapping-float-to-int — Enable nontrapping float-to-int operations
--disable-nontrapping-float-to-int — Disable nontrapping float-to-int operations
--enable-simd — Enable SIMD operations and types
--disable-simd — Disable SIMD operations and types
--enable-bulk-memory — Enable bulk memory operations
--disable-bulk-memory — Disable bulk memory operations
--enable-bulk-memory-opt — Enable memory.copy and memory.fill
--disable-bulk-memory-opt — Disable memory.copy and memory.fill
--enable-call-indirect-overlong — Enable LEB encoding of call-indirect (Ignored for compatibility as it has no effect on Binaryen)
--disable-call-indirect-overlong — Disable LEB encoding of call-indirect (Ignored for compatibility as it has no effect on Binaryen)
--enable-exception-handling — Enable exception handling operations
--disable-exception-handling — Disable exception handling operations
--enable-tail-call — Enable tail call operations
--disable-tail-call — Disable tail call operations
--enable-reference-types — Enable reference types
--disable-reference-types — Disable reference types
--enable-multivalue — Enable multivalue functions
--disable-multivalue — Disable multivalue functions
--enable-gc — Enable garbage collection
--disable-gc — Disable garbage collection
--enable-memory64 — Enable memory64
--disable-memory64 — Disable memory64
--enable-relaxed-simd — Enable relaxed SIMD
--disable-relaxed-simd — Disable relaxed SIMD
--enable-extended-const — Enable extended const expressions
--disable-extended-const — Disable extended const expressions
--enable-strings — Enable strings
--disable-strings — Disable strings
--enable-multimemory — Enable multimemory
--disable-multimemory — Disable multimemory
--enable-stack-switching — Enable stack switching
--disable-stack-switching — Disable stack switching
--enable-shared-everything — Enable shared-everything threads
--disable-shared-everything — Disable shared-everything threads
--enable-fp16 — Enable float 16 operations
--disable-fp16 — Disable float 16 operations
--enable-custom-descriptors — Enable custom descriptors (RTTs) and exact references
--disable-custom-descriptors — Disable custom descriptors (RTTs) and exact references
--enable-multibyte — Enable multibyte array loads and stores
--disable-multibyte — Disable multibyte array loads and stores

✨ every single one of those has an --enable- / --disable- twin, so if you turn a feature on you can always turn it right back off. balance, bestie 💖

--enable-relaxed-atomics — turns ON acquire/release atomic memory operations ✨
--disable-relaxed-atomics — turns OFF acquire/release atomic memory operations 🙈
--enable-custom-page-sizes — turns ON custom page sizes 💅
--disable-custom-page-sizes — turns OFF custom page sizes 💅
--enable-wide-arithmetic — turns ON wide arithmetic 🔥
--disable-wide-arithmetic — turns OFF wide arithmetic 🔥
--enable-compact-imports — turns ON the compact import section 🎀
--disable-compact-imports — turns OFF the compact import section 🎀
--enable-typed-function-references — deprecated compatibility flag ⚠️ (yes bestie, it's a legacy thing, no cap)
--disable-typed-function-references — deprecated compatibility flag ⚠️ (same energy, other direction)
--no-validation,-n — straight up disables validation, because it just assumes ur inputs are correct 😭 like okay queen, live dangerously
--pass-arg,-pa — an argument that gets passed along to the optimization passes being run. Has to be in the form KEY@VALUE, fr fr. If KEY is the name of a pass, then it applies to the closest instance of that pass before us. If KEY isn't the name of a pass, then it's a global option that applies to all pass instances that read it 👑
--closed-world,-cw — assume code outside of the module doesn't inspect or interact with GC and function references, even if they get passed out. The outside may hold on to them and pass them back in, but it won't inspect their contents or call them 🫶
--preserve-type-order — preserve the order of types from the input (lowkey useful for debugging and testing) 🦋
--generate-stack-ir — generate StackIR during writing ✨
--optimize-stack-ir — optimize StackIR during writing 💖
--print-stack-ir — print StackIR during writing 🌸
--no-stack-ir — do not use StackIR (even when it is the default) 💀

🌈 General options 🌈

--version — output version information and exit 👋
--help,-h — show this help message and exit 🥰
--debug,-d — print debug information to stderr 🐛

and that's the whole thing bestie, ur officially a wasm2js scholar 📚✨ it's giving main character compiler energy tbh. this was wasm2js 131, dated August 2026, and if u ever forget a flag just come back and reread ur girl's notes 💜 no gatekeeping, periodt 🎀

📦 where this page comes from

ubuntu stonking: binaryen 131-2 · Apache-2.0
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-11-02: a language model's rewrite of the original, under its terms