workers-wasi
wasi-sdk
workers-wasi | wasi-sdk | |
---|---|---|
5 | 11 | |
119 | 1,141 | |
0.0% | 3.5% | |
0.0 | 7.8 | |
about 1 year ago | 11 days ago | |
C++ | Shell | |
BSD 3-clause "New" or "Revised" License | Apache License 2.0 |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
workers-wasi
-
WASM by Example
The examples seemed clear enough to read (I did not test them), but I felt than even when teaching by example there needs to be more overview and explanation. I.e., I would prefer an overview of WASM structure and use with examples, rather than just the examples. (I have some (but limited) experience using WASM.)
As for the utility of wasm, note also that Cloudflare workers can run WASM on edge servers [1], and that the Swift community has some support for compiling to wasm [2].
I've never really understood how wasm could do better than java bytecode, but I've been impressed with how much people are using lua and BPF. More generally, in a world of federated programming, we need languages client can submit that providers can run safely, without obviously leaking any secret sauce -- perhaps e.g., for model refinement or augmented lookup.
[1] https://github.com/cloudflare/workers-wasi
-
SQLite builds for WASI since 3.41.0
Those are great questions! I believe Emscripten will be required for some cases as it provides more features for targeting a Web Browser. If WASI is the only requirement for a Wasm module, then there are three possible solutions:
- Use a library that provides the WASI bindings in a browser environments: there are some OSS projects that provides WASI bindings on top of browser technologies. For example, workers-wasi from Cloudflare [1]. It could be even another Wasm module that provides the implementation for the main one. I know the people from Loophole Labs are experimenting with virtual filesystems (VFS) [2].
- Browsers provides a WASI implementation: server-oriented runtimes like NodeJS are already providing these bindings (under a experimental flag). I shouldn't have stated that as a fact, as browsers may provide it or not. However, I saw in the past the Google Chrome team experimenting with WASI and the browser FileSystem API [3]. So, I think it may happen :)
- [1] https://github.com/cloudflare/workers-wasi
- [2] https://www.youtube.com/watch?v=46jZSXVxYPw
- [3] https://github.com/GoogleChromeLabs/wasi-fs-access
-
The Tug-of-War over Server-Side WebAssembly
Indeed, some people are doing this:
- WASI once had an official polyfill https://wasi.dev/polyfill/, now apparently succeeded by https://github.com/bjorn3/browser_wasi_shim
- wasmer-js provides a JS polyfill for WASI https://docs.wasmer.io/integrations/js/wasi
- Cloudflare has a WIP polyfill https://github.com/cloudflare/workers-wasi
I'm generally leery of non-temporary polyfills, so I'm not sure that any of these feel like a long-term viable option for me.
-
Rust advocacy at a medium-sized startup
I think modern C++ could be perfectly viable as well. Maybe https://github.com/cloudflare/workers-wasi would be a good starting point? I'm not too knowledgeable on the subject. Exciting times though, I think WASM might be the great equalizer.
-
Store SQLite in Cloudflare Durable Objects
While there is a WASI implementation for Workers: cloudflare/workers-wasi, I prefer to implement each import manually - especially when there are so few and especially while I am still experimenting. This helps me to keep the full picture of what's going on.
wasi-sdk
-
Stop Hiding the Sharp Knives: The WebAssembly Linux Interface
I would really love being able to take any POSIX command line tool, compile that to WASI, and run it on (at least) Linux, Windows and macOS like a regular executable without having to install a separate WASI runtime.
I'm a 'WASI convert' since I was able to take an ancient 8-bit assembler written in the mid-90's (http://xi6.com/projects/asmx/), compile that as-is with the WASI SDK (https://github.com/WebAssembly/wasi-sdk), and then integrate it into a VSCode extension (https://marketplace.visualstudio.com/items?itemName=floooh.v...).
A similar problem is I have is a shader cross-compiler (https://github.com/floooh/sokol-tools) which needs to run Linux, macOS and Windows and takes too long to build locally, thus I currently need to distribute that as pre-built binaries. Compiling this to WASI works, but the filesystem access restrictions built into current wasm runtimes are a hassle to manage, and it would require a WASI runtime to be separately installed).
-
WASI: WebAssembly System Interface
There is the WASI SDK if you want to target WASI from C/C++:
https://github.com/WebAssembly/wasi-sdk
It may not have all the amenities of Emscripten, but it's way less bulky.
-
How to Debug WASI Pipelines with ITK-Wasm
The most direct way to debug WebAssembly is through the WebAssembly System Interface (WASI). In itk-wasm, we can build to WASI with the WASI SDK by specifying the itkwasm/wasi toolchain image. A backtrace can quickly be obtained with the itk-wasm CLI. Or, a fully fledged debugger session can be started with LLDB.
-
Hello Wasm World!
We use the add_executable command to build executables with itk-wasm. The Emscripten and WASI toolchains along with itk-wasm build and execution configurations are contained in itk-wasm dockcross Docker images invoked by the itk-wasm command line interface (CLI). Note that the same code can also be built and tested with native operating system toolchains. This is useful for development and debugging.
-
Wasmer takes WebAssembly libraries mainstream with WAI
A more lightweight tool than emscripten is the WASI SDK (https://github.com/WebAssembly/wasi-sdk/releases). However, it doesn't generate JS or HTML.
-
A First Look at Wasm and Docker
wget https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-16/wasi-sdk-16.0-macos.tar.gz
-
Turbocharge your application development using WebAssembly with SingleStoreDB
First, we’ll download the wasi-sdk. We’ll use wasi-sdk-16.0-linux.tar.gz, the latest version available when writing this article. We’ll move the file to the /opt directory and unpack it as follows:
-
whats all the fuzz about wasi-libc?
I'm intrigued. Pretty good write-up about it here. One would need an ebuild for wasi-libc and an ebuild for wasi-sdk.
-
Store SQLite in Cloudflare Durable Objects
The previously mentioned PR for wasm32-unknown-unknown compatibility solved this by including libc .c files from OpenBSD. My go to solution is different though. I prefer to build using the wasi-sdk (a WASI-enabled WebAssembly C/C++ toolchain).
-
WebAssembly and Back Again: Fine-Grained Sandboxing in Firefox 95
There's also the https://github.com/WebAssembly/wasi-sdk repo which is kind of a meta-build-system for all this.
But in FreeBSD we build all the pieces directly, here's our build recipes (with some hacks due to llvm's cmake code being stupid sometimes):
compiler-rt (from llvm): https://github.com/freebsd/freebsd-ports/blob/main/devel/was...
libc (from what you linked): https://github.com/freebsd/freebsd-ports/blob/main/devel/was...
libc++ (from llvm): https://github.com/freebsd/freebsd-ports/blob/main/devel/was...
What are some alternatives?
workers-rs - Write Cloudflare Workers in 100% Rust via WebAssembly
wasi-libc - WASI libc implementation for WebAssembly
asyncify - Standalone Asyncify helper for Binaryen
binaryen - Optimizer and compiler/toolchain library for WebAssembly
wasm-sqlite - [Experimental] SQLite compiled to WASM with pluggable page storage.
linux - Linux kernel source tree
do-sqlite - [Experimental] Persist SQLite in a Cloudflare Durable Object
nxdk - The cross-platform, open-source SDK to develop for original Xbox: *new* xdk