WASM-METADCE(1)

📦

version 131 · 3 versions

✨ NAME ✨

wasm-metadce — the tool from the wasm-metadce(1) manual page that does dead code elimination (DCE) on a bigger space than just the wasm module 💖 it's giving very "I see the whole graph, not just the wasm" energy.

🦋 DESCRIPTION 🦋

okay bestie, buckle up, because this one's a whole vibe ✨

wasm-metadce INFILE

So here's the tea 🍓: this tool performs dead code elimination (DCE) on a larger space that the wasm module is just a part of. Like, if you have JS and wasm that are connected, this can DCE the combined graph. And by doing that, it's able to eliminate wasm module exports, which otherwise regular optimizations cannot. periodt 💅

This tool receives a representation of the reachability graph that the wasm module resides in, which contains abstract nodes and connections showing what they reach. Some of those nodes can represent the wasm module's imports and exports. The tool then completes the graph by adding the internal parts of the module, and does DCE on the entire thing. iconic behavior, honestly 👑

This tool will output a wasm module with dead code eliminated, and metadata describing the things in the rest of the graph that can be eliminated as well. 🎀

The graph description file should represent the graph in the following JSON-like notation — and note, bestie, this is not true JSON: things like comments, escaping, single-quotes, etc. are not supported 🙈

[

{

"name": "entity1", "reaches": ["entity2, "entity3"], "root": true

}, {

"name": "entity2", "reaches": ["entity1, "entity4"]

}, {

"name": "entity3", "reaches": ["entity1"], "export": "export1"

}, {

"name": "entity4", "import": ["module", "import1"]

},

]

Each entity has a name and an optional list of the other entities it reaches. It can also be marked as a root, export (with the export string), or import (with the module and import strings). DCE then computes what is reachable from the roots. 🌈

🛠️ wasm-opt options

--output, -o — the output file, aka where the slay goes 💾
--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
--emit-text, -S — emit text instead of binary for the output file
--debuginfo, -g — emit names section and debug info 🐛
--graph-file, -f — filename of the graph description file (the very graph we're DCE-ing, bestie)
--dump, -d — dump the combined graph file (useful for debugging) 🔍

💅 Optimization passes

like. there are SO many. and every single one of them matters, so we're not skipping a single one fr fr 🫶

--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 (our main character, lowkey 💀)
--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, destructively, we said what we said
--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 that's the spelling, no we will not be fixing it, respect the source 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
--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 — 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 — prints a map that links function indexes to their names. It's literally the backstage pass of function identity 🎟️✨
--print-minified — prints in minified s-expression format. Tiny text, zero fluff, maximum compactness 💅
--propagate-debug-locs — propagates debug location from parents or previous siblings down to child nodes. Debug info said pass it down and it did 🧚
--propagate-globals-globally — propagates global values to other globals (useful for tests). Globals helping globals, we love to see it 🫶
--remove-exports — removes exports using a wildcard. Wildcard said begone 👋
--remove-imports — removes imports and replaces them with nops. Imports? Never heard of her 💀
--remove-memory — removes memory init (legacy name). Bestie this is the legacy name, so it's giving old-school 😭
--remove-memory-init — removes memory initialization. The glow-up version of the legacy one ✨
--remove-non-js-ops — removes operations that are incompatible with js. If JS can't sit with it, it's out 🚫
--remove-relaxed-simd — replaces relaxed SIMD instructions with unreachable. Relaxed? Not anymore, bestie 💅
--remove-unused-brs — removes breaks from locations that are not needed. Unnecessary breaks? We don't know them 🙈
--remove-unused-module-elements — removes unused module elements. Decluttered, organized, iconic ✨
--remove-unused-names — removes names from locations that are never branched to. If nobody branches to you, why are you named? 💀
--remove-unused-nonfunction-module-elements — removes unused module elements that are not functions. Non-function elements, you are dismissed 🫡
--remove-unused-types — remove unused private GC types. Private types that nobody uses? Bye 👋
--reorder-functions — sorts functions by access frequency. Most-used functions first, main character energy 👑
--reorder-functions-by-name — sorts functions by name (useful for debugging). Alphabetical order said let me cook 🍳
--reorder-globals — sorts globals by access frequency. Globals getting reordered by how popular they are 💅
--reorder-locals — sorts locals by access frequency. Locals said rate me by my usage 📈
--reorder-types — sorts private types by access frequency. Private types, this is your popularity contest 🏆
--rereloop — re-optimizes control flow using the relooper algorithm. Control flow said makeover time 🦋
--roundtrip — writes the module to binary, then reads it. A little binary vacation, then back home 🏠
--rse — remove redundant local.sets. Three letters, one job, lowkey iconic 💅
--safe-heap — instruments loads and stores to check for invalid behavior. Safety first, bestie 🦺
--separate-data-segments — writes data segments to a file and strips them from the module. Data segments said I need space 📁
--set-globals — sets specified globals to specified values. Globals getting assigned, no cap 🎯
--signature-pruning — removes params from function signature types where possible. Params that aren't needed? Pruned ✂️
--signature-refining — applies more specific subtypes to signature types where possible. Signature said be more specific 🔍
--signext-lowering — lowers sign-ext operations to wasm mvp and disables the sign extension feature. Downgraded to mvp, respectfully 💅
--simplify-globals — miscellaneous globals-related optimizations. Globals getting a little self-care 🧖
--simplify-globals-optimizing — miscellaneous globals-related optimizations, and optimizes where we replaced global.gets with constants. Constants said we ate 🍽️
--simplify-locals — miscellaneous locals-related optimizations. Locals getting simplified, periodt 💅
--simplify-locals-nonesting — miscellaneous locals-related optimizations (no nesting at all; preserves flatness). Flatness preserved, no nesting drama 🫶
--simplify-locals-nostructure — miscellaneous locals-related optimizations (no structure). Structure? Never met her 💀
--simplify-locals-notee — miscellaneous locals-related optimizations (no tees). Tees are not invited to this party 🚫
--simplify-locals-notee-nostructure — miscellaneous locals-related optimizations (no tees or structure). No tees, no structure, just vibes ✨
--souperify — emit Souper IR in text form. Souper IR said read me 📝
--souperify-single-use — emit Souper IR in text form (single-use nodes only). Single-use nodes only, exclusive club 💅
--spill-pointers — spill pointers to the C stack (useful for Boehm-style GC). Pointers said spill the tea ☕
--ssa — ssa-ify variables so that they have a single assignment. One variable, one assignment, one destiny 💫
--ssa-nomerge — ssa-ify variables so that they have a single assignment, ignoring merges. Single assignment, but merges are ignored 🙈
--stack-check — enforce limits on llvm's __stack_pointer global. Stack pointer said boundaries, bestie 🚧
--string-gathering — gathers wasm strings to globals. Strings said come together right now 🎶
--string-lifting — lift string imports to wasm strings. Imports getting lifted up, glow-up style ✨
--string-lowering — lowers wasm strings and operations to imports. Strings going down to imports, respectfully 💅
--string-lowering-magic-imports — same as string-lowering, but encodes well-formed strings as magic imports. Magic imports said abracadabra 🪄
--string-lowering-magic-imports-assert — same as string-lowering-magic-imports, but raise a fatal error if there are invalid strings. Invalid strings? Fatal error, no cap 💀
--strip — deprecated; same as strip-debug. Bestie, deprecated 😭 same energy as strip-debug
--strip-debug — strip debug info (including the names section). Debug info stripped, names section included in the yeet 🧹
--strip-dwarf — strip dwarf debug info. Dwarf debug info said I'm out 👋
--strip-eh — strip EH instructions. EH instructions stripped, periodt 💅
--strip-producers — strip the wasm producers section. Producers section? Gone 🫡
--strip-target-features — strip the wasm target features section. Target features section said not today 🚫
--strip-toolchain-annotations — strip all toolchain-specific code annotations. Toolchain annotations, you are dismissed 💅
--stub-unsupported-js — stub out unsupported JS operations. Unsupported JS said stub me out 🪵
--symbolmap — alias for print-function-map. Same map, different name, iykyk 🗺️
--table64-lowering — alias for memory64-lowering. Alias behavior, no extra thoughts 💭
--trace-calls — instrument the build with code to intercept specific function calls. Calls getting traced like true crime 🔍
--translate-to-exnref — translate old Phase 3 EH instructions to new ones with exnref. Old Phase 3 said makeover 💅
--translate-to-new-eh — deprecated; same as translate-to-exnref. Deprecated bestie, same as translate-to-exnref 😭
--trap-mode-clamp — replace trapping operations with clamping semantics. Traps said clamp it 🗜️
--trap-mode-js — replace trapping operations with js semantics. Traps said JS vibes only 💛
--tuple-optimization — optimize trivial tuples away. Trivial tuples said bye 👋
--type-finalizing — mark all leaf types as final. Leaf types said final answer ✅
--type-merging — merge types to their supertypes where possible. Types merging like a friend group 🤝
--type-refining — apply more specific subtypes to type fields where possible. Type fields said be more specific 🔍
--type-refining-gufa — apply more specific subtypes to type fields where possible (using GUFA). Same as above but GUFA said let me help 🫶
--type-ssa — create new types to help other optimizations. New types on the block, helping the team 👑
--type-unfinalizing — mark all types as non-final (open). Final? Not anymore, we open now 🚪
--unsubtyping — removes unnecessary subtyping relationships. Unnecessary relationships? Removed 🚫
--untee — removes local.tees, replacing them with sets and gets. Tees said we're replaced 💅
--vacuum — removes obviously unneeded code. Code getting vacuumed, obviously 🧹

⚡ Optimization options ⚡

-O — execute default optimization passes (equivalent to -Os). Default energy, size-focused slay ✨
-O0 — execute no optimization passes. Optimization said not today 🚫
-O1 — execute -O1 optimization passes (quick&useful opts, useful for iteration builds). Quick and useful, perfect for iteration vibes 🔁
-O2 — execute -O2 optimization passes (most opts, generally gets most perf). Most opts, generally most perf, main character of optimization levels 👑
-O3 — execute -O3 optimization passes (spends potentially a lot of time optimizing). It may take a lot of time, but it's committed 🕰️
-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). More time, more memory, more nesting support, highkey intense 🔥
-Os — execute default optimization passes, focusing on code size. Code size said small is beautiful 🎀
-Oz — execute default optimization passes, super-focusing on code size. Super-focusing on size, tiny queen behavior 💅
--optimize-level, -ol — How much to focus on optimizing code. Dial in your optimization obsession level 🎛️
--shrink-level, -s — How much to focus on shrinking code size. Dial in your shrinking obsession level 📉
--debuginfo, -g — Emit names section in wasm binary (or full debuginfo in wast). Debug info said include me 🪪
--always-inline-max-function-size, -aimfs — Max size of functions that are always inlined (default 2, which is safe for use with -Os builds). Default 2, safe with -Os builds, no cap 🧢
--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. Lightweight only, no loops or calls, default 20, aggressive speed mode 🏎️
--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). Default -1, which means all such functions are inlined, only-one-caller energy 📞
--inline-max-combined-binary-size, -imcbs — Max size of combined functions after inlining. Default: 409600. Default 409600, combined size limit, respect it 📏
--inline-functions-with-loops, -ifwl — Allow inlining functions with loops. Loops are invited to the inline party 🔄
--partial-inlining-ifs, -pii — Number of ifs allowed in partial inlining (zero means partial inlining is disabled) (default: 0). Default 0, zero ifs means partial inlining is disabled 🚫
--ignore-implicit-traps, -iit — Optimize under the helpful assumption that no surprising traps occur (from load, div/mod, etc.). Assumption: no surprising traps, helpful but bold 😌
--traps-never-happen, -tnh — Optimize under the helpful assumption that no trap is reached at runtime (from load, div/mod, etc.). Assumption: no trap is reached at runtime, living dangerously ✨
--low-memory-unused, -lmu — Optimize under the helpful assumption that the low 1K of memory is not used by the application. Assumption: low 1K of memory is unused, okay bestie 🧠
--fast-math, -ffm — Optimize floats without handling corner cases of NaNs and rounding. Floats optimized, NaNs and rounding corner cases not handled 💅
--zero-filled-memory, -uim — Assume that an imported memory will be zero-initialized. Assumption: imported memory is zero-initialized, clean slate energy 🧼
--skip-pass, -sp — Skip a pass (do not run it). Pass said not running 🏃‍♀️

🧰 Tool options 🧰

--mvp-features, -mvp — Disable all non-MVP features. MVP only, non-MVP features said peace out ✌️
--all-features, -all — Enable all features. Everything on, all features invited, no exclusions 🎉
--detect-features — (deprecated - this flag does nothing). Deprecated and fr it does absolutely nothing, ghost flag 👻
--quiet, -q — Emit less verbose output and hide trivial warnings. Less yapping, trivial warnings hidden 🤫
--experimental-poppy — Parse wast files as Poppy IR for testing purposes. Poppy IR said it's giving experimental 🧪
--emit-module-names — Emit module names, even if not emitting the rest of the names section. Names emitted even without the rest, independent queen 👑
--enable-sign-ext — Enable sign extension operations. Sign extension operations enabled ✅
--disable-sign-ext — Disable sign extension operations. Sign extension operations disabled ❌
--enable-threads — Enable atomic operations. Atomic operations enabled ⚛️
--disable-threads — Disable atomic operations. Atomic operations disabled 🚫
--enable-mutable-globals — Enable mutable globals. Mutable globals enabled 💅
--disable-mutable-globals — Disable mutable globals. Mutable globals disabled 🛑
--enable-nontrapping-float-to-int — Enable nontrapping float-to-int operations. Nontrapping float-to-int enabled ✨
--disable-nontrapping-float-to-int — Disable nontrapping float-to-int operations. Nontrapping float-to-int disabled 💀
--enable-simd — Enable SIMD operations and types. SIMD operations and types enabled 🔥
--disable-simd — Disable SIMD operations and types. SIMD operations and types disabled 🚫
--enable-bulk-memory — Enable bulk memory operations. Bulk memory operations enabled 🧠
--disable-bulk-memory — Disable bulk memory operations. Bulk memory operations disabled 😭
--enable-bulk-memory-opt — Enable memory.copy and memory.fill. memory.copy and memory.fill enabled 💾
--disable-bulk-memory-opt — Disable memory.copy and memory.fill. memory.copy and memory.fill disabled 🚫
--enable-call-indirect-overlong — Enable LEB encoding of call-indirect (Ignored for compatibility as it has no effect on Binaryen). Ignored for compatibility, no effect on Binaryen, so don't stress 🧘
--disable-call-indirect-overlong — Disable LEB encoding of call-indirect (Ignored for compatibility as it has no effect on Binaryen). Also ignored for compatibility, also no effect on Binaryen, twins 💅
--enable-exception-handling — Enable exception handling operations. Exception handling operations enabled 🚨
--disable-exception-handling — Disable exception handling operations. Exception handling operations disabled 🛑
--enable-tail-call — Enable tail call operations. Tail call operations enabled 🐾
--disable-tail-call — Disable tail call operations. Tail call operations disabled 🚫
--enable-reference-types — Enable reference types. Reference types enabled 🫶
--disable-reference-types — Disable reference types. Reference types disabled ❌
--enable-multivalue — Enable multivalue functions. Multivalue functions enabled ✨
--disable-multivalue — Disable multivalue functions. Multivalue functions disabled 💀
--enable-gc — turn garbage collection on 💚
--disable-gc — turn garbage collection off
--enable-memory64 — turn 64-bit memory on
--disable-memory64 — turn 64-bit memory off
--enable-relaxed-simd — turn relaxed SIMD on
--disable-relaxed-simd — turn relaxed SIMD off
--enable-extended-const — turn extended const expressions on
--disable-extended-const — turn extended const expressions off
--enable-strings — turn strings on 🎀
--disable-strings — turn strings off
--enable-multimemory — turn multimemory on
--disable-multimemory — turn multimemory off
--enable-stack-switching — turn stack switching on
--disable-stack-switching — turn stack switching off
--enable-shared-everything — turn shared-everything threads on
--disable-shared-everything — turn shared-everything threads off
--enable-fp16 — turn float 16 operations on
--disable-fp16 — turn float 16 operations off
--enable-custom-descriptors — turn custom descriptors (RTTs) and exact references on
--disable-custom-descriptors — turn custom descriptors (RTTs) and exact references off
--enable-multibyte — turn multibyte array loads and stores on
--disable-multibyte — turn multibyte array loads and stores off
--enable-relaxed-atomics — turn acquire/release atomic memory operations on
--disable-relaxed-atomics — turn acquire/release atomic memory operations off
--enable-custom-page-sizes — turn custom page sizes on
--disable-custom-page-sizes — turn custom page sizes off
--enable-wide-arithmetic — turn wide arithmetic on
--disable-wide-arithmetic — turn wide arithmetic off
--enable-compact-imports — turn the compact import section on
--disable-compact-imports — turn the compact import section off
--enable-typed-function-references — deprecated compatibility flag 👀 it's giving "legacy era", bestie
--disable-typed-function-references — deprecated compatibility flag 👀 same vibe, other direction
--no-validation, -n — no cap, this one just turns validation ALL the way off. It straight up assumes your inputs are correct, which… girl. If they're not, that's between you and the consequences 💀
--pass-arg, -pa — an argument you hand off to the optimization passes that are running. Has to be shaped like KEY@VALUE. If KEY matches the name of a pass, it lands on the closest instance of that pass sitting before us. If KEY isn't a pass name, then it's a global option, and it applies to literally every pass instance that reads it ✨
--closed-world, -cw — assume the code outside the module does not inspect or interact with GC and function references, even if they get passed out. The outside can hold on to them and pass them back in, but it can't peek inside them or call them 👑
--preserve-type-order — keep the types in the same order they came in from the input (so useful for debugging and testing, fr fr) 🧚
--generate-stack-ir — generate StackIR while writing
--optimize-stack-ir — optimize StackIR while writing
--print-stack-ir — print StackIR while writing
--no-stack-ir — don't use StackIR at all (even when it's the default) 🙈

🌈 General options 🌈

--version — spit out the version info and dip 🦋
--help, -h — show this help message and exit, bestie's always got you 🫶
--debug, -d — print debug information to stderr 🔥

And that's the whole page, babes — part 3 done, we ate and left no crumbs 💅<br> This one's wasm-metadce, version 131, dated August 2026, and it lives at WASM-METADCE(1). Go forth and debug, queen 👑⭐

📦 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