Convert WASM to WAT Online Free
Disassemble binary WebAssembly into human-readable text format with WABT's wasm2wat. Inspect imports, exports, functions, and the instruction stream — useful for debugging, code review, and patching modules.
By ChangeThisFile Team · Last updated: March 2026
ChangeThisFile converts binary WASM to WebAssembly Text (WAT) using WABT's wasm2wat — the canonical reference disassembler. The output is an S-expression text file with sections for imports, exports, types, functions, tables, memories, globals, and the linear instruction stream. Round-trips cleanly back to WASM with wat2wasm. Free, encrypted upload, files auto-deleted after conversion.
Convert WebAssembly Binary (WASM) to WebAssembly Text (WAT)
Drop your WebAssembly Binary (WASM) file here to convert it instantly
Drag & drop your .wasm file here, or click to browse
Convert to WebAssembly Text (WAT) instantly
WebAssembly Binary (WASM) vs WebAssembly Text (WAT): Format Comparison
Key differences between the two formats
| Feature | WASM (binary) | WAT (text) |
|---|---|---|
| Representation | Compact binary | S-expression text |
| Readability | Disassembler required | Human-readable |
| File size | Compact | Verbose (typical 3-10× larger) |
| Spec | WebAssembly binary format | WebAssembly text format |
| Use case | Distribution, runtime loading | Reading, debugging, patching |
| Loaders | WebAssembly.instantiate(), engines | Tooling (wat2wasm, IDEs) |
| Round-trip | Lossless to/from WAT | Lossless to/from WASM |
When to Convert
Common scenarios where this conversion is useful
Inspecting a third-party WASM module
Disassemble a `.wasm` file you didn't write to see what it imports, exports, and does. Useful for security review and dependency auditing.
Debugging a compiler bug
When Rust, AssemblyScript, or another source-to-WASM compiler produces unexpected output, the text format lets you reason about the actual instructions emitted.
Patching a binary
Disassemble, hand-edit the WAT to add a custom section or fix an import, then re-assemble with wat2wasm — no source toolchain required.
Teaching WebAssembly internals
Show students or teammates the actual instruction stream behind a high-level WebAssembly source. WAT is the right level for understanding the stack machine.
Who Uses This Conversion
Tailored guidance for different workflows
For WebAssembly Developers
- Inspect a third-party `.wasm` to audit imports and exports before integrating
- Debug why a compiled module is larger or slower than expected by reading the actual instructions
- Patch a binary without rebuilding from source — disassemble, edit, re-assemble
For Security Researchers
- Audit a WASM binary for unexpected imports (e.g., suspicious host functions)
- Look for known-bad opcode sequences in user-uploaded WASM
- Diff two versions of a binary by comparing their WAT representations
How to Convert WebAssembly Binary (WASM) to WebAssembly Text (WAT)
-
1
Upload your .wasm file
Drop your WebAssembly binary module. Up to 50MB per upload on the anonymous endpoint.
-
2
Server-side disassembly with WABT
wasm2wat reads the binary, validates the section structure, and emits a canonical text representation with sections for types, imports, functions, tables, memories, globals, exports, and code.
-
3
Download the WAT text
Your `.wat` file is delivered as a download. The uploaded binary is deleted from disk immediately after the response.
Developers: convert via API →
Frequently Asked Questions
Yes. wasm2wat and wat2wasm are inverses — the WAT output, re-assembled, produces the same WASM bytes. Function names from the optional `name` custom section are preserved when present.
Only if the binary includes a `name` custom section (most Rust, AssemblyScript, and Emscripten outputs do unless stripped). Without it, functions are labeled `$func0`, `$func1`, etc. — semantics are unchanged but readability suffers.
MVP plus widely-shipped extensions: multi-value, reference types, bulk memory, sign-extension, non-trapping float-to-int, SIMD, and threads. Newer proposals (GC types, component model, exception handling drafts) follow whatever WABT currently ships.
DWARF and source-map data live in custom sections. wasm2wat preserves them as raw bytes in the WAT output (under `(@custom "..." ...)` annotations) but doesn't render them into source-level WAT comments.
Yes — output of any spec-compliant WASM toolchain disassembles cleanly. Larger compiler-emitted binaries (Rust/Emscripten releases easily hit several MB) work as long as they're under the 50MB upload limit.
50MB per upload on the anonymous endpoint, 5 requests per minute per IP. Use the authenticated /v1/convert API for larger binaries.
Yes. HTTPS upload, ephemeral temp directory, files deleted immediately after the conversion response. Contents are not logged.
Yes — use the WAT to WASM converter. The round trip is lossless as long as your edits respect the spec. WABT will surface validation errors with line and column if you produce something invalid.
WABT is the canonical implementation; shipping it in the browser would mean a multi-MB WASM-of-WABT bundle. Server-side keeps the page small and the disassembler version up to date.
Related Conversions
Need to convert programmatically?
Use the ChangeThisFile API to convert WebAssembly Binary (WASM) to WebAssembly Text (WAT) in your app or script. Free tier included.
Ready to convert your file?
Convert WebAssembly Binary (WASM) to WebAssembly Text (WAT) instantly — free, no signup required.
Start Converting