wizer VS wagi

> once by the wasm runtime to compile the rust-python wasm

I'm not sure what you mean by that. The runtime doesn't compile WASM, it simply executes it.

There are tools for dealing with interpreter runtime overhead this by pre-initalizing the environment like Wizer[0]. ComponentizeJS[1] uses it to pre-initialize the Spidermoney engine it packages to gain fast startup times (and you can then prune the initialization only code with wasm-opt). As techniques like ComponentizeJS are also being applied for a specific set of interpreted files, you can even prune parts of the interpreter that would never be used for that specific program. If you want to go even further you could record specific execution profiles and optimize further by those.

[0]: https://github.com/bytecodealliance/wizer

[1]: https://github.com/bytecodealliance/ComponentizeJS

Edge functions are typically run intermittently, with their runtime stopped to free up resources between runs. Therefore a big factor is startup and shutdown speed. Containers are pretty bad there. Deno is better, and WASM is unbeatable, especially with things like Wizer[0].

[0]https://github.com/bytecodealliance/wizer

I imagine startup cost could be amortized by something like wizer: https://github.com/bytecodealliance/wizer

There are security benefits to running each request in its own instance, as it helps prevent accidental leaking of state between requests. To avoid doing lots of expensive initializations, we have a tool called wizer which lets users run their program's initialization once, create a snapshot, and then use that snapshot to do fast startups that don't rerun the whole initialization each time.

See https://github.com/bytecodealliance/wizer for an implementation of this approach.

It should probably be named "Making JavaScript to startup fast on WebAssembly", since the runtime speed is not really improved by the approach they exposed.

Besides that I think Wizer [1] is both an elegant and a simple solution to speed up startup speed with Wasm.

[1] - https://github.com/bytecodealliance/wizer#using-wizer-as-a-l...

A similar project, for WebAssembly so with limited scope is this: https://github.com/bytecodealliance/wizer. And somehow similar but limited on LLVM IR a colleague worked on this for Cheerp (the compiler used here as backend): https://github.com/leaningtech/cheerp-meta/wiki/Cheerp-PreExecuter.

WAGI and WCGI are the WASM based spiritual successors.

https://github.com/deislabs/wagi

https://wasmer.io/posts/announcing-wcgi

Compile a CGI program in any language to WASI, then use https://github.com/deislabs/wagi to run it.

Yeah of course! They've got STDIN/STDOUT/STDERR and I've built a Virtual Filesystem. But if you're using WASI binaries locally they don't have that restriction.

You might be interested in WAGI: https://github.com/deislabs/wagi

And to catch up on WASI: https://xeiaso.net/talks/unix-philosophy-logical-extreme-was...

As I'm sure you've heard, WASM has been growing in popularity and use over the past few years. And with the creation of WASI (Web Assembly System Interface) and WAGI (Web Assembly Gateway Interface), WASM is starting to venture outside of running just in the browser. And in the case of WAGI, if you've been programming since the earlier days of the internet, it might feel very similar to CGI programming (and that's because it's based on CGI1.1!) WAGI provides a way for developers to define handlers for HTTP requests and route them to specific functions inside of, or entire, WASM modules. It does so by piping the headers of the incoming request to os.Args[1:], piping the body of the incoming request to os.Stdin, and writing the response to os.Stdout. (To learn more about configuring, routing, compiling, and deploying WAGI routes, as well as the limitations of WAGI routes, please consult the WAGI docs and the TinyGo WASM docs)

What do you think of WAGI [1], which is basically CGI for WASM modules.

[1]: https://github.com/deislabs/wagi/blob/main/docs/writing_modu...

as serverless functions (https://github.com/deislabs/wagi)

I'm experimenting with WASM & Rust but with a different framework named wagi, there's a great video by Rainer Stropek & Stefan Baumgartner that gives a little introduction to it [0]

[0]: https://www.youtube.com/watch?v=9NDwHBjLlhQ

[1]: https://github.com/deislabs/wagi

Krustlet and WAGI are two such projects.

It does support it, the runtime we are currently using enables that -- see https://github.com/deislabs/wagi/blob/main/docs/writing_modu...

Good point on the docs, I will open an issue and add some information about it, thanks!