wasmer-go VS maturin

The next step is to create a Go project and run our wasm file with some runtime. For this, I chose wasmer-go.

However, there are other, more fleshed-out, libraries like wasmer-go that provides a runtime and help us navigate around these limitations. The wasmer-go documentation provides a good summary of these challenges:

wasmer-go

I did some research and found a WebAssembly runtime that can run Go code that has been compiled to WASM. It seems to me that one could implement a plugin system using this. I might try.

Thank you Syrus, appreciate your work with Wasmer. Congrats on the 3.0 release and Windows support! I just fixed guregu/trealla on WAPM to work with the latest changes. I think WAPM is very cool and I hope more people start doing releases on it.

These are the two issues I'm referring to:

https://github.com/wasmerio/wasmer-go/pull/200

https://github.com/wasmerio/wasmer-go/pull/286

Time to implement the other side of the story. I have found a WebAssembly runtime for Go. Wasmer-go is a complete and mature WebAssembly runtime for Go based on Wasmer.

If performance is your main concern, there's Wasmer-go, but if you'd rather avoid CGO dependencies, there's wazero.

See wasmer-go for server-side runtime.

I've been looking at wasmer-go, and it seems to be quite performant given that the runtime is written in Rust and invoked through CGo bindings. Is this what everyone is using?

Go: I don't know of anything higher-level than either exposing a C ABI from Rust and then calling it using cgo or using wasmer-go to embed a WebAssembly runtime in your Go program.

This story unfolds as a captivating journey where the agile Flounder, representing the Python programming language, navigates the vast seas of coding under the wise guidance of Sebastian, symbolizing Rust. Central to their adventure are three powerful tridents: cargo, PyO3, and maturin.

-- Maturin on GitHub

My new favorite way to write very fast libraries for Python is to just use Rust and Maturin:

https://github.com/PyO3/maturin

It basically automates everything for you. If you use it with Github actions, it will compile wheels for you on each release for every platform and python version you want, and even upload them to PyPi (pip) for you. Everything feels very modern and well thought out. People really care about good tooling in the Rust world.

Python first, you will be able to experiment quickly with the notebooks. Then maybe write (or rewrite) some modules in Rust that you can expose as python modules, with py03 and maturin. Feel free to publish useful packages on both crates.io and pypi.org, so you can contribute to Python and Rust ecosystems.

Now if you really want to use Rust, you can rewrite only the part that are slowing down your consumer. It's easy by using Py03 and maturin. Maybe also rayon to parallelize.

It's relatively easy to extend Python with project like Py03[0] and Maturin[1]. Polars[2] is the perfect example of that.

It's not easy to push coworkers/companies to use an unfamiliar language. Rust isn't fast to learn. You need very good arguments and a good usecase to make it works.

I doubt that learning Rust will help you more that learning more about the data engineers tools, so this isn't really "worth" your time.

[0] -- https://pyo3.rs/v0.18.3/

[1] -- https://github.com/PyO3/maturin

[2] -- https://www.pola.rs/

In this case, PyO3/maturin does all the setup and getting the module into Python. They also have docs going into a lot more depth on this.

Lastly if you're willing to introduce Rust, I'd consider a gradual approach using native libraries built in rust with PYO3. Check the maturin guide that helps you to streamline the build process of native libraries : https://github.com/PyO3/maturin . From there you could try to find hotspots in your python app and replace those with a native implementation.