wasmer | 🚀 The leading WebAssembly Runtime supporting WASI | Binary Executable Format library

I can answer part of your question:

I'm missing is WASI support in wee8? Does it exist?

No, wee8 does not implement WASI. Adding such support is theoretically possible, but not currently scheduled to get done.

You can implement it yourself in your wee8 embedder, and make it available to loaded modules via imports. Most (or all?) of it could probably be a reusable (among many engine implementations) library, potentially offered and maintained by the WASI project itself. (I don't know whether such a library exists already.)

You didn't say what imports object you're currently passing; it needs to be an array of wasm::Extern* pointers that's at least as long as the imports of the module, and ordered equivalently (i.e. imports[i] will be the module's ith import).

(I agree that the Wasm C/C++ API is very barebones currently. Unless/until that is changed, you'll have to build any convenience mechanisms yourself. It's all possible with the information that's available, it's just clearly less convenient than instantiating Wasm modules from JavaScript.)

I see nothing wrong with that. Targeting 32bits means that the memory addressing is 32bits. For this reason before the memory store instruction, all you have are 32bit instructions (i.e. the offset and the value are i32) you have this at some point:

Compilers will often inline functions and remove code that isn't used, this is why your C program ends up with everything inside a _start function. As explained in the FAQ you may list functions to export using emcc -s EXPORTED_FUNCTIONS=_main,_matrix in order to prevent them from being inlined or removed. Adding this results in a wasm module with the function correctly exported.

As for running functions directly, the source code for wasmer run has logic to determine which runtime environment should be exposed to the module. However, if you pass -i function, it entirely skips the environment setup and runs your function directly. In this case, the modules fails to initialize because it imports functions from WASI (in order to write things to the console, and get the current clock time).

I believe the reason why wasm32-unknown-unknown works is that it doesn't link to any runtime, and implements dummy interfaces for things that it can't simulate (all filesystem calls result in errors, etc.)

In summary, wasmer run -i function isn't meant to run functions from modules that have imports, it might be possible to patch wasmer-cli for that, but I'm not sure if it would work across all runtime environments.

Currently in Rust we can really only create WASI binaries, not libraries. WASI only works for the duration of a main function that needs to be there. Calling the wasi functions from anywhere else segfaults because libpreopen isn't initialized.

So to summarize, how to fix this currently:

• Do not have lib.crate-type at all
• Have the file be src/main.rs, not src/lib.rs
• Have #![no_main] at the top of the src/main.rs
• Use RUSTFLAGS="-Z wasi-exec-model=reactor" cargo +nightly build --target wasm32-wasi
• Make sure that you call _initialize before anything else

https://github.com/WebAssembly/WASI/issues/24

https://github.com/rust-lang/rust/pull/79997

In my case:

wasi_fs_example/src/main.rs:

I think generating and running LLVM IR using the C++ API will be the best solution, unless another option is presented. Though the code generation might be low-level, it supports all relevant platforms, can cross compile, and has exceptional performance.

The library in pip is outdated. The current version is from March, 2nd, and the necessary changes were implemented only on June, 2nd. 0.4.2 beta version is outdated also (May, 19). So, the only way now is manual build. Probably the library will be updated in a couple of weeks.

See more details in this thread: https://github.com/wasmerio/python-ext-wasm/issues/215.

Copy data to WebAssembly memory (for example WebAssembly memory address 0):

What they're saying is that you can embed Wasmer runtime itself in various languages, and then use such embeddings to run WebAssembly compiled from any other source language, as long as it's using WASI API for any input / output.

You can find a list of currently supported embedding targets on their documentation page or on their Github account.

As of time of this writing supported targets include:

• Rust
• C / C++
• Python
• Go
• PHP
• Ruby
• C#
• R
• Elixir
• Postgres

Different targets have different level of readiness, support and documentation, but you can ask more specific questions when you start playing with a specific target.