Rust's WebAssembly (Wasm) targets are undergoing a significant change that may break existing projects. For years, the --allow-undefined flag was automatically passed to wasm-ld during linking, allowing undefined symbols to be silently imported. This flag is now being removed to align Wasm behavior with native platforms and catch errors earlier. This article explains the change, its implications, and how to adapt your code.
# What is changing in Rust's WebAssembly targets?
Starting soon, Rust's WebAssembly targets will no longer pass the --allow-undefined flag to wasm-ld during linkage. This flag previously permitted undefined symbols—like functions declared in extern "C" blocks—to be silently turned into WebAssembly imports. Its removal means that any undefined symbol encountered at link time will now cause a compilation error instead of being allowed. This shift aims to make Rust's WebAssembly behavior consistent with native targets, where such errors are caught immediately. Projects relying on this flag to link against external C libraries or other Wasm modules will need to adapt by explicitly defining or importing those symbols.
# What exactly does the --allow-undefined flag do?
The --allow-undefined flag, when passed to wasm-ld, tells the linker to ignore unresolved symbols. In WebAssembly, symbols correspond to functions or globals used in the code. If a Rust program calls a function declared via extern "C" { fn my_func(); }, the linker normally expects to find a definition for my_func. With --allow-undefined, the linker instead creates an import for that symbol from the WebAssembly environment (e.g., (import "env" "my_func")). This effectively punts the responsibility of supplying the function to runtime or the embedding host. While useful in early days, it masks errors like typos or missing libraries, leading to broken modules that fail at runtime.
# Why was --allow-undefined used historically?
The exact origins are unclear, but --allow-undefined was likely a practical necessity when WebAssembly support first landed in Rust. In the early days, the toolchains and linkers were immature, and many dependencies (like libc or platform-specific functions) were not yet compiled to WebAssembly. Allowing undefined symbols enabled projects to get off the ground by deferring resolution to the runtime. Over time, this workaround became default behavior, even as the ecosystem matured and native WebAssembly libraries became available. However, this default now diverges from how other platforms work, where undefined symbols are caught at compile time. The upcoming removal restores consistency and catches mistakes earlier.
# What are the problems with using --allow-undefined?
The main issue is that --allow-undefined suppresses errors during compilation, pushing them to runtime. For example, if you typo a function name—writing mylibraryinit instead of mylibrary_init—the linker will create an import for the misspelled name, and the actual function will never be called. Similarly, if you forget to link a required C library, the resulting Wasm module will import nonexistent symbols, causing failures only when executed. This lengthens the feedback loop between introducing a bug and discovering it. On native platforms, such mistakes produce immediate linker errors. Removal of the flag makes Wasm behavior consistent, reducing silent failures and improving development reliability.
# How can Rust developers handle this change?
To adapt, you need to ensure all symbols referenced in your WebAssembly code are properly resolved at link time. For external functions from C libraries or host environments, use the #[link(wasm_import_module = "module_name")] attribute and define the import explicitly. For example:
#[link(wasm_import_module = "env")]
extern "C" {
fn mylib_init();
}If you previously relied on --allow-undefined to import arbitrary functions from the host, you must now declare them with the correct module and name. For projects linking to precompiled C code, ensure all object files are included in the link command (e.g., using the wasm-pack or cargo build flags). Tools like cargo web or wasm-bindgen also have built-in support for imports. Check your dependencies and update build scripts to avoid undefined symbols.
# What are undefined symbols in the WebAssembly context?
In WebAssembly, a symbol is a named entity (function, global, or memory) that is either defined within the module or expected to be provided by the environment. When a Rust program uses extern "C" to declare a function, that function becomes an undefined symbol—the linker must find its definition. Without --allow-undefined, if no definition exists (e.g., from another object file or library), the linker errors out. With the flag, it instead generates an import instruction in the Wasm binary, like (import "env" "my_symbol"). This means the undefined symbol is silently transformed into a runtime dependency. The flag's removal forces you to explicitly state these dependencies, making the build process fail early if a symbol is missing—a safer approach for producing robust WebAssembly modules.