WASM-OPT(1)

📦

version 131 · 3 versions

🌸 NAME 🌸

okay so bestie, welcome to wasm-opt 💖 it's a User Commands manual page and its whole entire job is: read, write, and optimize files. that's it, that's the vibe. 🦋

✨ DESCRIPTION ✨

================================================================================

wasm-opt INFILE

Read, write, and optimize files. 💅

Example usage:

wasm-opt input.wasm -O3 -o output.wasm

so basically: it reads an input wasm file, optimizes with -O3, and writes out the result. iconic. no notes. 👑

For more on how to optimize effectively, see

https://github.com/WebAssembly/binaryen/wiki/Optimizer-Cookbook
https://github.com/WebAssembly/binaryen/wiki/GC-Optimization-Guidebook

================================================================================

🎀 wasm-opt options 🎀

like, the main-character flags, fr fr:

--output, -o — Output file. where the lil guy goes when it's done 🫶
--emit-text, -S — Emit text instead of binary for the output file. so you can read it with your eyeballs 👀
--converge, -c — Run passes to convergence, continuing while binary size decreases. it just keeps going while the numbers go down, obsessed 📉
--fuzz-exec-before, -feh — Execute functions before optimization, helping fuzzing find bugs. shake it around first and see what falls out 🐛
--fuzz-exec, -fe — Execute functions before and after optimization, helping fuzzing find bugs. before and after, we love a comparison moment ✨
--fuzz-exec-second — A second module to link with the first, for --fuzz-exec-before (only before, as optimizations are not applied to it). a little plus-one module 🧚
--extra-fuzz-command, -efc — An extra command to run on the output before and after optimizing. The output is compared between the two, and an error occurs if they are not equal. if they don't match bestie, it's a whole thing 💀
--translate-to-fuzz, -ttf — Translate the input into a valid wasm module *somehow*, useful for fuzzing. yes "somehow" is the official energy here 🙈
--initial-fuzz, -if — Initial wasm content in --translate-to-fuzz (-ttf) mode.
--fuzz-passes, -fp — When doing --translate-to-fuzz, pick a set of random passes from the input to further shape the wasm. chaos but make it structured 🌪️
--no-fuzz-memory — don't emit memory ops when fuzzing.
--no-fuzz-oob — don't emit out-of-bounds loads/stores/indirect calls when fuzzing.
--fuzz-preserve-imports-exports — don't add imports and exports in -ttf mode, and keep the start. do not perceive them, do not add them 🚫
--fuzz-against-js — modify the wasm in valid ways that assume it is used only from JS.
--fuzz-import — a module to use as an import in -ttf mode.
--emit-spec-wrapper, -esw — Emit a wasm spec interpreter wrapper file that can run the wasm with some test values, useful for fuzzing.
--emit-wasm2c-wrapper, -esw — Emit a C wrapper file that can run the wasm after it is compiled with wasm2c, useful for fuzzing. (yes bestie it's the same -esw short flag as the one above, that's literally what the page says, i do not make the rules 💅)
--input-source-map, -ism — Consume source map from the specified file.
--output-source-map, -osm — Emit source map to the specified file.
--output-source-map-url, -osu — Emit specified string as source map URL.
--experimental-new-eh — Deprecated; same as --emit-exnref. it's giving "we're literally so over this one" 😭
--emit-exnref — After running all requested transformations / optimizations, translate the instruction to use the new EH instructions at the end. Depending on the optimization level specified, this may do some more post-translation optimizations. a lil afterparty pass 🎉

🔥 Optimization passes 🔥

the pass list. it's long. it's giving encyclopedia. we're doing all of them, no skips, periodt. 💜

--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 ⏸️▶️
--avoid-reinterprets — Tries to avoid reinterpret operations via more loads
--cfp — propagate constant struct field values
--cfp-reftest — propagate constant struct field values, using ref.test
--coalesce-locals — reduce # of locals by coalescing
--coalesce-locals-learning — reduce # of locals by coalescing and learning
--code-folding — fold code, merging duplicates
--code-pushing — push code forward, potentially making it not always execute
--const-hoisting — hoist repeated constants to a local
--constraint-analysis — finds and uses mathematical constraints on locals
--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
--dae2 — Experimental reimplementation of DAE
--dce — removes unreachable code 🗑️
--dealign — forces all loads and stores to have alignment 1
--denan — instrument the wasm to convert NaNs into 0 at runtime
--dfo — optimizes using the DataFlow SSA IR
--directize — turns indirect calls into direct ones
--discard-global-effects — discards global effect info
--duplicate-function-elimination — removes duplicate functions
--duplicate-import-elimination — removes duplicate imports
--dwarfdump — dump DWARF debug info sections from the read binary
--emit-target-features — emit the target features section in the output
--enclose-world — modify the wasm (destructively) for closed-world ⚠️ yes bestie it says destructively, read it again
--extract-function — leaves just one function (useful for debugging)
--extract-function-index — leaves just one function selected by index
--flatten — flattens out code, removing nesting
--fpcast-emu — emulates function pointer casts, allowing incorrect indirect calls to (sometimes) work 🙃
--func-metrics — reports function metrics
--generate-dyncalls — generate dynCall functions used by emscripten ABI
--generate-global-effects — generate global effect info (helps later passes)
--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
--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)
--inlining-optimizing — inline functions and optimizes where we inlined
--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
--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
--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 (yes, spelled like that in the original, i'm just the messenger 🍓)
--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
--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) 🙈
--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
--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 — all the lil miscellaneous glow-ups for code that Emscripten made 💖
--precompute — crunches expressions that can be figured out at compile time, so they're just... already done ✨
--precompute-propagate — same energy as --precompute, except it also pushes those computed values through your locals, no cap 🫶
--print — prints everything in s-expression format 🌸
--print-boundary — prints the boundary in JSON format, iconic 🎀
--print-call-graph — prints the call graph, so you can see who's calling whom (drama map fr) 💅
--print-features — prints the options for the features you've got enabled, so you know exactly what you're working with ✨
--print-full — prints in the full s-expression format, extra detailed bestie 🌈
--print-function-map — prints a map of function indexes to names, iykyk 🗺️
--print-minified — prints in minified s-expression format, compact queen 💅
--propagate-debug-locs — carries debug locations down from parents or previous siblings onto their child nodes 🧚
--propagate-globals-globally — propagates global values into other globals (handy for tests) 💜
--remove-exports — yeets exports using a wildcard 😭
--remove-imports — takes imports out and swaps them for nops, gone but not forgotten 💀
--remove-memory — removes memory init (this is the legacy name, so it's giving vintage) 🎀
--remove-memory-init — removes memory initialization ✨
--remove-non-js-ops — strips out operations that js can't vibe with 🚫
--remove-relaxed-simd — swaps relaxed SIMD instructions out for unreachable 🌸
--remove-unused-brs — removes breaks that are sitting at locations where they're just not needed 🙈
--remove-unused-module-elements — removes module elements nobody's using, decluttering era 🧹
--remove-unused-names — removes names from locations that are never branched to ✨
--remove-unused-nonfunction-module-elements — removes unused module elements that aren't functions (yes, specifically the non-function ones) 💅
--remove-unused-types — removes unused private GC types 🫶
--reorder-functions — sorts functions by access frequency, hottest first 🔥
--reorder-functions-by-name — sorts functions by name (this one's for debugging, so cute) 🎀
--reorder-globals — sorts globals by access frequency 🔥
--reorder-locals — sorts locals by access frequency 🔥
--reorder-types — sorts private types by access frequency 🔥
--rereloop — re-optimizes control flow using the relooper algorithm, we love a rerun 👑
--roundtrip — writes the module out to binary, then reads it right back in. a lil circular moment ✨
--rse — removes redundant local.sets 🧚
--safe-heap — instruments loads and stores so they check for invalid behavior 👀
--separate-data-segments — writes data segments out to a file and strips them from the module 📦
--set-globals — sets the globals you specify to the values you specify 🎯
--signature-pruning — removes params from function signature types wherever it possibly can ✂️
--signature-refining — applies more specific subtypes to signature types wherever possible 💅
--signext-lowering — lowers sign-ext operations down to wasm mvp and turns the sign extension feature off 🌸
--simplify-globals — all the miscellaneous globals-related optimizations ✨
--simplify-globals-optimizing — same miscellaneous globals-related optimizations, plus it optimizes wherever we swapped global.gets out for constants 🫶
--simplify-locals — all the miscellaneous locals-related optimizations 💖
--simplify-locals-nonesting — miscellaneous locals-related optimizations, but with no nesting at all — it preserves flatness 🧊
--simplify-locals-nostructure — miscellaneous locals-related optimizations, no structure edition 🌈
--simplify-locals-notee — miscellaneous locals-related optimizations, no tees edition 🎀
--simplify-locals-notee-nostructure — miscellaneous locals-related optimizations with absolutely no tees and no structure. minimalist queen 💅
--souperify — emits Souper IR in text form ✍️
--souperify-single-use — emits Souper IR in text form, but single-use nodes only 🍓
--spill-pointers — spills pointers onto the C stack (this is the one for Boehm-style GC) 🌊
--ssa — ssa-ifies your variables so every one of them gets a single assignment 🎯
--ssa-nomerge — ssa-ifies your variables so each gets a single assignment, ignoring merges 🙅
--stack-check — enforces limits on llvm's __stack_pointer global 🚧
--string-gathering — gathers wasm strings up into globals 🧺
--string-lifting — lifts string imports up into wasm strings 🎈
--string-lowering — lowers wasm strings and operations down into imports ⬇️
--string-lowering-magic-imports — same as string-lowering, except it encodes well-formed strings as magic imports ✨
--string-lowering-magic-imports-assert — same as string-lowering-magic-imports, except it raises a fatal error if there are invalid strings 💀
--strip — deprecated; same as strip-debug ⚠️
--strip-debug — strips debug info, and that includes the names section 🧹
--strip-dwarf — strips dwarf debug info 🧹
--strip-eh — strips EH instructions 🧹
--strip-producers — strips the wasm producers section 🧹
--strip-target-features — strips the wasm target features section 🧹
--strip-toolchain-annotations — strips out every toolchain-specific code annotation 🧹
--stub-unsupported-js — stubs out the JS operations that aren't supported 🙈
--symbolmap — (alias for print-function-map) 🗺️
--table64-lowering — alias for memory64-lowering 🔁
--trace-calls — instruments the build with code that intercepts specific function calls 👀
--translate-to-exnref — translates old Phase 3 EH instructions into the new ones with exnref 🔄
--translate-to-new-eh — deprecated; same as translate-to-exnref ⚠️
--trap-mode-clamp — replaces trapping operations with clamping semantics 🧲
--trap-mode-js — replaces trapping operations with js semantics 🟨
--tuple-optimization — optimizes trivial tuples right out of existence 🫥
--type-finalizing — marks every leaf type as final 🍃
--type-merging — merges types into their supertypes wherever possible 🫂
--type-refining — applies more specific subtypes to type fields wherever possible 💅
--type-refining-gufa — applies more specific subtypes to type fields wherever possible, using GUFA ✨
--type-ssa — creates new types to help out the other optimizations (team player fr) 🫶
--type-unfinalizing — marks every type as non-final (open) 🔓
--unsubtyping — removes the subtyping relationships that aren't necessary ✂️
--untee — removes local.tees and replaces them with sets and gets 🔁
--vacuum — sucks up code that's obviously unneeded 🧹

🚀 Optimization options 🚀

bestie this is the big one. the -O dial. turn it up, turn it down, pick your fighter 💖

-O — run the default optimization passes (it's equivalent to -Os) ✨
-O0 — run no optimization passes at all. nothing. raw. 😌
-O1 — run the -O1 optimization passes: quick & useful opts, great for iteration builds 🔁
-O2 — run the -O2 optimization passes: most of the opts, generally gets you most of the perf 📈
-O3 — run the -O3 optimization passes: it spends potentially a lot of time optimizing, and honestly? it's worth it 🔥
-O4 — run the -O4 optimization passes: this one also flattens the IR, which can take a lot more time and memory, but it's genuinely useful on more nested / complex / less-optimized input 💅
-Os — run the default optimization passes, but focusing on code size 📦
-Oz — run the default optimization passes with super-focus on code size. teeny tiny 👑
--optimize-level,-ol — how much to focus on optimizing code ⚡
--shrink-level,-s — how much to focus on shrinking code size 🐜
--debuginfo,-g — emit the names section in the wasm binary (or full debuginfo in wast) 🐛
--always-inline-max-function-size,-aimfs — the max size of functions that are always inlined (default 2, which is safe to use with -Os builds) 🫶
--flexible-inline-max-function-size,-fimfs — the max size of functions that get inlined when they're lightweight (no loops or function calls) while optimizing aggressively for speed (-O3). Default: 20 🪶
--one-caller-inline-max-function-size,-ocimfs — the max size of functions that get inlined when there's only one caller (default -1, which means all such functions are inlined) ☝️
--inline-max-combined-binary-size,-imcbs — the max size of combined functions after inlining. Default: 409600 📏
--inline-functions-with-loops,-ifwl — allow inlining of functions that have loops 🔄
--partial-inlining-ifs,-pii — the 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 ever reached at runtime (from load, div/mod, etc.) 🙈
--low-memory-unused,-lmu — optimize under the helpful assumption that the low 1K of memory isn't used by the application 🧠
--fast-math,-ffm — optimize floats without handling the corner cases of NaNs and rounding 🌊
--zero-filled-memory,-uim — assume that an imported memory will be zero-initialized 0️⃣
--skip-pass,-sp — skip a pass (as in, don't run it) 🙅

🛠️ Tool options 🛠️

--mvp-features,-mvp — disable every non-MVP feature 🚫
--all-features,-all — enable every feature. all of them. the whole buffet 🍽️
--detect-features — (deprecated - this flag does nothing) 💀
--quiet,-q — emit less verbose output and hide the trivial warnings. peace and quiet era 🤫
--experimental-poppy — parse wast files as Poppy IR, for testing purposes 🌼
--emit-module-names — emit module names, even if you're 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, since it has no effect on Binaryen) 🤷
--disable-call-indirect-overlong — disable LEB encoding of call-indirect (ignored for compatibility, since it has no effect on Binaryen) 🤷
--enable-exception-handling — turns ON exception handling operations 💖
--disable-exception-handling — turns OFF exception handling operations
--enable-tail-call — turns ON tail call operations ✨
--disable-tail-call — turns OFF tail call operations
--enable-reference-types — turns ON reference types 🎀
--disable-reference-types — turns OFF reference types
--enable-multivalue — turns ON multivalue functions 🦋
--disable-multivalue — turns OFF multivalue functions
--enable-gc — turns ON garbage collection 🌸
--disable-gc — turns OFF garbage collection
--enable-memory64 — turns ON memory64 💅
--disable-memory64 — turns OFF memory64
--enable-relaxed-simd — turns ON relaxed SIMD 🫶
--disable-relaxed-simd — turns OFF relaxed SIMD
--enable-extended-const — turns ON extended const expressions 😭
--disable-extended-const — turns OFF extended const expressions
--enable-strings — turns ON strings 🔥
--disable-strings — turns OFF strings
--enable-multimemory — turns ON multimemory 👑
--disable-multimemory — turns OFF multimemory
--enable-stack-switching — turns ON stack switching 🌈
--disable-stack-switching — turns OFF stack switching
--enable-shared-everything — turns ON shared-everything threads ⭐
--disable-shared-everything — turns OFF shared-everything threads
--enable-fp16 — turns ON float 16 operations 💀
--disable-fp16 — turns OFF float 16 operations
--enable-custom-descriptors — turns ON custom descriptors (RTTs) and exact references 🙈
--disable-custom-descriptors — turns OFF custom descriptors (RTTs) and exact references
--enable-multibyte — turns ON multibyte array loads and stores 🍓
--disable-multibyte — turns OFF multibyte array loads and stores
--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 compact import section ✨
--disable-compact-imports — turns OFF compact import section
--enable-typed-function-references — deprecated compat flag, bestie, it's just vibing here for the old days 💀
--disable-typed-function-references — also a deprecated compatibility flag, same energy 🙈
--no-validation, -n — disables validation, and yes it literally just assumes your inputs are correct 😭 it does NOT check for you, it trusts you completely, which is either iconic or terrifying depending on the day
--pass-arg, -pa — an argument you pass along to whatever optimization passes are being run 🫶. It must be in the form KEY@VALUE. 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 does not inspect or interact with GC and function references, even if they are passed out 🌍. The outside may hold on to them and pass them back in, but not inspect their contents or call them.
--preserve-type-order — preserve the order of types from the input (so good for debugging and testing, fr fr) 🌸
--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 🌈

the little housekeeping besties, the ones you actually need every single day

--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, you made it to the end 💖 this was wasm-opt from version 131, dated August 2026, and the page you just read is WASM-OPT(1). go forth and optimize, no cap 👑✨

📦 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