awesome-wasm-runtimes
jco
awesome-wasm-runtimes | jco | |
---|---|---|
8 | 9 | |
1,275 | 518 | |
- | 7.1% | |
1.9 | 9.4 | |
2 months ago | 4 days ago | |
Rust | ||
- | 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.
awesome-wasm-runtimes
-
Extism Makes WebAssembly Easy
Firecracker is a fine technology, but serverless companies have started taking advantage Wasm's faster start-up times for use cases of running Wasm on the server (https://www.youtube.com/watch?v=yqgCxhPAao0). The deny by default security policy makes Wasm a great choice to run your code in isolation, particularly for maximizing hardware resources in the multi-tenant environments these serverless companies operate.
In the past few years, we have seen more use cases of Wasm emerge outside of the browser. JavaScript engines are now just a fraction of the total number of runtimes available. Wasmtime, Wasmer, WasmEdge, wazero are popular ones for non-browser use cases like blockchain, serverless, and edge computing (although Cloudflare uses V8's Wasm engine). WAMR is a popular one for cyber physical/IoT devices. There's a nice list here: https://github.com/appcypher/awesome-wasm-runtimes
-
I think [...] the "future of computing" is going to be [...] CISC. I’ve read of IBM mainframes that have [hardware instructions for] parsing XML [...]; if you had garbage collection, bounds checking, and type checking in hardware, you’d have fewer and smaller instructions that achieved just as much.
There's plenty of other ways to interact with Wasm, most of which are secure. (Wasmtime is the one I'm most familiar with, which is why I linked to it.)
-
Lunatic is an Erlang-inspired runtime for WebAssembly
Yeah, this is one of many non-browser runtimes, e.g. see https://github.com/appcypher/awesome-wasm-runtimes
Lunatic is more opinionated than most of these or node, though, in that it's trying to emulate a particular concurrent system design pattern borrowed from Erlang/BEAM.
-
Web Assembly OS guidance
There's an overview of different WASM runtimes with features: https://github.com/appcypher/awesome-wasm-runtimes
- Wasmer – The Universal WebAssembly Runtime
-
What to learn in 2022
Now, the creation Bytecode Alliance, the development of multiple WebAssembly runtimes and the work of the W3C WebAssembly Community Group is why I belive it will get popular, but the capability-based security model is why I want it to get popular.
-
Ho Ho Ho, WasmEdge 0.9.0 is here!
⚖ I think it's really cool that a plugin author could compile their C++ to .wasm such that a single plugin binary can run on either Linux or Windows (don't need an x86 .dll, x64 .dll, x86 .so, x64 .so...) and in a sandbox (no arbitrary syscalls or Win32 calls, just the interfaces given to it), while still getting near native AOT speed. Though, it's hard to judge which one to choose from now with all the wasm engines that are available (https://github.com/appcypher/awesome-wasm-runtimes), with wasmtime or inNative being two others I've considered for my project. I'll definitely look into this one though, given it supports many of the newer proposals.
-
Why WebAssembly is innovative even outside the browser
Numerous native runtimes for webassembly already exist[0], with the current popular choices apparently being Wasmer[1] and Wasmtime[2].
All one would need to do (AFAIK) is ship a client for all major platforms, as is done with Electron (and web browsers themselves, and everything else.)
[0]https://github.com/appcypher/awesome-wasm-runtimes
jco
-
WASI 0.2.0 and Why It Matters
> WASI-Preview2's benefits are not going to be realized in a browser, it's more for the non-web world
The jco project (https://github.com/BytecodeAlliance/jco) provides an implementation of the Component Model and WASI Preview 2 for JavaScript systems. Right now, node.js support is complete, but support for Web embeddings is in progress and coming soon.
> These interpreted languages can run in WASM, but only as language interpreter inside the WASM interpreter - so they work, but they are not efficient.
The Bytecode Alliance has made big improvements to SpiderMonkey performance on WASM/WASI systems, and has work in progress to take advantage of SpiderMonkey's "native" codegen targeting WASM: https://cfallin.org/blog/2023/10/11/spidermonkey-pbl/. We targeted JS first for this work because it is the most popular language with our customers and users, but we expect that this will show the path to adding similar improvements to Ruby, Python, and other languages commonly thought of as "interpreted".
-
The New Wasmer JavaScript SDK
I use @wasmer/wasi for my npm package `trealla` (wasm port of a Prolog interpreter). For the most part I'm pretty happy with it, but the file size is quite large[1] (taking up around half my bundle size), and it looks like @wasmer/sdk is even larger (wasmer.sh downloads a 1.7MB gzipped wasm binary that I assume is the runtime). It's a tough sell to the frontend folks when my package is this big... currently I have my eye on jco[2] which I hope will be much lighter.
[1]: https://bundlephobia.com/package/@wasmer/[email protected]
[2]: https://github.com/bytecodealliance/jco
-
Lightweight, portable and secure Wasm runtimes and their use cases.
You literally write the code in the language you prefer, and given the toolchain is in place -and it's in (experimental or preview) place for JavaScript, with teams working on it, like for example JCO- you can compile with Wasm as target.
-
Prettier $20k Bounty was Claimed
The roadmap I linked above. The WASI folks have done a poor job at communicating, no doubt, but I'm surprised someone like yourself literally building a competitor spec isn't following what they are doing closely.
Just for you I did some googling: see here[0] for the current status of WASI threads overall, or here[1] and here[2] for what they are up to with WASI in general. In this PR[3] you can see they enabled threads (atomic instructions and shared memory, not thread creation) by default in wasmtime. And in this[4] repository you can see they are actively developing the thread creation API and have it as their #1 priority.
If folks want to use WASIX as a quick and dirty hack to compile existing programs, then by all means, have at it! I can see that being a technical win. Just know that your WASIX program isn't going to run natively in wasmtime (arguably the best WASM runtime today), nor will it run in browsers, because they're not going to expose WASIX - they're going to go with the standards instead. so far you're the only person I've met that thinks exposing POSIX fork() to WASM is a good idea, seemingly because it just lets you build existing apps 'without modification'.
Comical you accuse me of being polarizing, while pushing for your world with two competing WASI standards, two competing thread creation APIs, and a split WASM ecosystem overall.
[0] https://github.com/bytecodealliance/jco/issues/247#issuecomm...
[1] https://bytecodealliance.org/articles/wasmtime-and-cranelift...
[2] https://bytecodealliance.org/articles/webassembly-the-update...
[3] https://github.com/bytecodealliance/wasmtime/pull/7285
[4] https://github.com/WebAssembly/shared-everything-threads
-
WASM by Example
The component model is already shipping in Wasmtime, and will be stable for use in Node.js and in browsers via jco (https://github.com/bytecodealliance/jco) soon. WASI Preview 2 will be done in December or January, giving component model users a stable set of interfaces to use for scheduling, streams, and higher level functionality like stdio, filesystem, sockets, and http on an opt-in basis. You should look at wit-bindgen (https://github.com/bytecodealliance/wit-bindgen) to see some of the languages currently supported, and more that will be mature enough to use very soon (https://github.com/bytecodealliance/componentize-py)
Right now jco will automatically generate the JS glue code which implements a Component Model runtime on top of the JS engine's existing WebAssembly implementation. So, yes, Components are a composition of Wasm Modules and JS code is handling passing values from one module/instance to another. You still get the performance benefits of running computation in Wasm.
One day further down the standardization road, we would like to see Web engines ship a native implementation of the Component Model, which might be able to make certain optimizations that the JS implementation cannot. Until then you can consider jco a polyfill for a native implementation, and it still gives you the power to compose isolated programs written in many languages and run them in many different contexts, including the Web.
(Disclosure: I am co-chair of WASI, Wasmtime maintainer, implemented many parts of WASI/CM)
-
Spin 2.0 – open-source tool for building and running WASM apps
(As a side note for the JS support — adapting QuickJS has been extremely helpful in getting JS support out; however, we are in the process of rebuilding the JS runtime using SpiderMonkey (with which a few people on the team have significant experience) and JCO (https://github.com/bytecodealliance/jco), and the web platform compatibility makes it a significantly better proposition for things like 3rd party dependencies).
C# is an interesting one — the .NET team at Microsoft (and in particular Steve Sanderson from that team) has been making tremendous progress in ahead-of-time compilation for .NET and generating Wasm and WASI compatible binaries (as opposed to their initial approach on Blazor), and experimenting with that led us to build support for Spin as well.
Finally, we do a lot to support other popular languages and their Wasm support — two examples: Python (https://github.com/bytecodealliance/componentize-py) and Java / TeaVM (https://github.com/fermyon/teavm-wasi), for which we haven't fully integrated Spin support, but we hope to get there soon.
I hope this explains a bit our process on language support, happy to expand on any point here.
-
Extism Makes WebAssembly Easy
That's really useful. This page in particular: https://github.com/bytecodealliance/jco/blob/main/EXAMPLE.md
Being able to run "jco wit cowsay.wasm" to see what interfaces that .wasm file provides solves a problem I've run into a bunch of times in the past.
- Sandboxing JavaScript Code
What are some alternatives?
wasmer - 🚀 The leading Wasm Runtime supporting WASIX, WASI and Emscripten
componentize-py
Graal - GraalVM compiles Java applications into native executables that start instantly, scale fast, and use fewer compute resources 🚀
modsurfer - Devtools to validate, audit and investigate WebAssembly binaries.
Odin - Odin Programming Language
quickjs-emscripten - Safely execute untrusted Javascript in your Javascript, and execute synchronous code that uses async functions
wasm-micro-runtime - WebAssembly Micro Runtime (WAMR)
extism - The framework for building with WebAssembly (wasm). Easily load wasm modules, move data, call functions, and build extensible apps.
TinyGo - Go compiler for small places. Microcontrollers, WebAssembly (WASM/WASI), and command-line tools. Based on LLVM.
js-string-builtins - JS String Builtins
Nim - Nim is a statically typed compiled systems programming language. It combines successful concepts from mature languages like Python, Ada and Modula. Its design focuses on efficiency, expressiveness, and elegance (in that order of priority).
memory-control - A proposal to introduce finer grained control of WebAssembly memory.