# WASM Component-based development (wiki) **URL:** \ **Category:** Sustainable open social systems\ **Created:** [May 25, 2023, 7:43am UTC](https://discuss.coding.social/t/wasm-component-based-development-wiki/367 "2023-05-25T07:43:21Z")\ **Posts on this page:** 1\ **Page:** 1
**Author:** ![system](https://discuss.coding.social/user_avatar/discuss.coding.social/system/32/929_2.png) [@system](https://discuss.coding.social/u/system)\ **Post date:** [May 25, 2023, 7:43am UTC](https://discuss.coding.social/t/wasm-component-based-development-wiki/367/1 "2023-05-25T07:43:21Z")
## WASM Technology survey This wiki contains may links to WebAssembly related resources that were encountered over time. And the wiki is updated as new resources are found. It is NOT meant to give an exhaustive overview of the field and its current status, but just serves to inspire on some of the ways that Wasm is used in-the-wild. #### Open standards: WASM, WASI, Component Model - WebAssembly 1.0 is [supported in all major browsers](https://caniuse.com/wasm). - [WebAssembly Core 2.0](https://www.w3.org/TR/wasm-core/) is undergoing a W3C recommendation process. - [WebAssembly System Interface](https://github.com/WebAssembly/WASI) is a modular set of specs that bring WASM to the server. - [WebAssembly Component Model](https://github.com/WebAssembly/component-model/tree/main) provides building blocks that WASI is built on top of. - [Bytecode Alliance](https://bytecodealliance.org/) promotes adoption, has production-ready implementations (in Rust). - [Cloud Native Computing Foundation](https://www.cncf.io) (part of Linux Foundation) tracks, creates WASM projects. Background reading: - [Clound Native Computing Foundation: WASM Developer Survey](https://www.cncf.io/blog/2022/10/24/cncf-wasm-microsurvey-a-transformative-technology-yes-but-time-to-get-serious/) (Oct 24, 2022) - [Developer Tooling for Cloud-Native Wasm Is Going Mainstream](https://www.infoq.com/news/2022/11/cloud-native-wasm-day/) (Nov 04, 2022) - [Evolution of Wasm Standards: Building the Component Model for Wasm](https://cosmonic.com/blog/engineering/evolution-of-wasm-standards-building-the-component-model) (Mar 8, 2023) - [The Four Domains of WASM](https://www.fermyon.com/blog/four-domains-wasm) (Mar 14, 2023) - [The Road Ahead: Insights from Wasm I/O on the Future of Web Assembly](https://blog.suborbital.dev/the-road-ahead-insights-from-wasm-io-on-the-future-of-web-assembly) (Apr 19, 2023) - [WebAssembly: a new development paradigm for the web @ Google I/O](https://yewtu.be/watch?v=RcHER-3gFXI) (May 10, 2023) - [Bytecode Alliance: WebAssembly Updated Roadmap for Developers](https://bytecodealliance.org/articles/webassembly-the-updated-roadmap-for-developers) (July 24, 2023) - [The State of WeAssembly Survey 2023](https://blog.scottlogic.com/2023/10/18/the-state-of-webassembly-2023.html) (Oct 18, 2023) - [WIT Cheat Sheet](https://cosmonic.com/blog/engineering/wit-cheat-sheet) by Cosmonic (Oct 10, 2023) > **[Verifying your browser…](https://yewtu.be/watch?v=pIcnh4Sl_xU)** The introduction of WASM to the server, the cloud, and the edge is more far-reaching than initially apparent. It opens a completely new paradigm to Component-based architecture. - Fine-grained plugin model. Modularity. Nano processes. Polyglot. - New software delivery model. Beyond containers. - Security-first design. Trustless computing. Capability-based security. - Performant, size/memory efficient, suitable from micro scale and upwards. - Focus on Developer Experience, ease of use. Minimize stack/infra maintenance. - Interoperability, portability. Based on open standards (e.g. Component Model). Terminology popularized by use cases & projects based on this approach (need not be WASM-related): - **FaaS** ([Function as a Service](https://en.wikipedia.org/wiki/Function_as_a_service)) - E.g. [Wasmer](https://wasmer.io/wasmer-for-faas), [FaaS in Go with WASM, WASI and Rust](https://news.ycombinator.com/item?id=35846443) (HN). - **Edge Serverless** - E.g. [WasmEdge](https://wasmedge.org) (“functions anywhere”). - **Universal FFI** ([Foreign Function Interface](https://en.wikipedia.org/wiki/Foreign_function_interface)) - E.g. [Extism](https://extism.org/), [E2Core](https://github.com/suborbital/e2core), [waPC](https://wapc.io/) (“universal plug-in systems”). #### What say the experts? In a recent publications (Google Doc turned PDF below), [Ian “Hixie” Hickson](https://en.wikipedia.org/wiki/Ian_Hickson), editor of the HTML specification for 10 years, in January 2023 criticises the use of hypermedia for intricate web applications, and proposes an alternate approach based on Wasm (defending it [on Hacker News](https://news.ycombinator.com/item?id=34612696)), among others: > By providing low-level primitives instead, applications could ship with their own implementations of high-level concepts like layout, widgets, and gestures, enabling a much richer set of interactions and custom experiences with much less effort on the part of the developer. > > As it happens, among the many high-level primitives, a few low-level APIs have been created and are available on the web today: > > - **WebAssembly** (also known as Wasm) provides a portable compilation target for programming languages beyond JavaScript; it is being actively extended with features such as WasmGC. > - **WebGPU** provides an API (to JavaScript) that exposes a modern computation and rendering pipeline. > - **ARIA** (Accessible Rich Internet Applications) provides an ontology for enabling accessibility of arbitrary content. > - **WebHID** provides an API (to JavaScript) that exposes the underlying input devices on the device. > > This document proposes to enable browsers to render web pages that are served not as HTML files, but as Wasm files, skipping the need for HTML, JS, and CSS parsing in the rendering of the page, by having the WebGPU, ARIA, and WebHID APIs exposed directly to Wasm. [Ian-Hickson\_Towards-a-modern-Web-stack\_2023.pdf](https://discuss.coding.social/uploads/short-url/s6YCz8krcJkSZNzD2XMe0orGWm3.pdf) (99.5 KB) (Tooted on the Fediverse [in this post](https://social.coop/@smallcircles/110445148829899767)) ### Solidground specific observations #### [Paradigm] Control the Supply Chain “WebAssembly Everywhere” represents a paradigm shift which allows fine-grained composition of services, that aligns perfectly to the idea of **App-Free Computing**. Control of the supply line, dependency management, new ways of packaging and deployment of solutions and a primary focus on Developer/DevOps Experience to bring productivity gains, represents a powerful value proposition. There’s a lot of attention for compliance and open standards, probably driven by the urgent Need and focus on Supply Chain control. An area where Free Software is _firmly_ in the rear guard, which represents a big threat. Prosperity Guilds is exploring the service [Software Supply Chain](https://discuss.coding.social/t/guilds-services-software-supply-chain-wiki/345) where Solidground can add value. > **[Solving the SBOM crisis with WebAssembly components](https://www.infoworld.com/article/2338406/solving-the-sbom-crisis-with-webassembly-components.html)** > > The Wasm component model addresses supply chain vulnerabilities by allowing the most up-to-date versions of imported libraries to be attached at runtime—enabling platforms to automate common application maintenance. Wrt packaging and deployment, the IT practices have gone crazy complex in recent years. The paradigm shift intends to address this low-hanging fruit of productivity gains. WebAssembly allows more fine-grained deployment (terminology found: ‘micro-microservices’, ‘nanoservices’). Docker is recognizing this: - Docker has [Wasm beta support](https://docs.docker.com/desktop/wasm/). See: [Announcing Docker+Wasm Technical Preview 2](https://www.docker.com/blog/announcing-dockerwasm-technical-preview-2/) (Mar 22, 2023). Regarding _software delivery model_ consider this diagram: ![Diagram showing deployment models from bare-metal to Distributed Wasm](https://discuss.coding.social/uploads/default/original/1X/2c60bcb4bc618ac8ac32a5ac05ed2dbef4c120b0.jpeg) In the diagram, where [Cosmonic](https://cosmonic.com) position themself is where the general WASM-based delivery model is (but without the Actor Model, which is added value offered by wasmCloud and Cosmonic). #### Component registries Related to Supply Chain above, but also Groundwork plugins and App-Free Computing needs.. > [`warg`](https://warg.io) is an in-development open source registry protocol for [Wasm](https://webassembly.org/) packages (components or ‘world’ interfaces). `warg` provides an index allowing everyone to refer to federated namespaces of Wasm packages without being opinionated about how package content is stored and hosted. Warg is: > > - [Component Model](https://github.com/webAssembly/component-model) oriented. > - Federated & highly interoperable. > - Content storage & delivery agnostic. > - Advancing supply-chain security. This protocol is still under development. #### [Paradigm] Small is Huge Going from a philosophy that “Small is Huge” → Everything works better when it is still small, and complexity comes with size. Solidgrounds wants to adhere to [Small Technology](https://small-tech.org) principles. Though there’s a lot of ‘cloud-native’ and ‘serverless’ terminology, the “Wasm Everywhere” paradigm facilitates _any scale_ and any _edge devices_. Whether services run on a microcontroller IoT devices, mobile phone, web browser, VPS or large cloud clusters.. it is all supported. > **Opportunity** : A niche exists for FOSS ecosystems that focus on ‘smallness’ in their offerings. What all the current vendors and tech companies exploring Wasm have in common is their love for ‘high scalability’. This is a flaw and a weakness that we in Free Software movement can benefit from. Our scale comes from Decentralization. > **Opportunity** : Polyglot being intrinsic to “Wasm Everywhere” fits fragmented grassroots efforts. @Ryuno-Ki mentioned the importance for [guild members](https://discuss.coding.social/t/unionize-free-software-found-software-guilds/59/4#unions-versus-guilds-4) to have enough alignment in technology use, in order offer most value in services exchange. WebAssembly can be the common glue technology, allowing any member to use their own preferred techstack. - SQLite gets official Wasm support with help from VMWare’s WasmLabs (see: [HN discussion](https://news.ycombinator.com/item?id=36054521)). #### [Concept] Capability-based programming WASI has a Capability-based security model. It is a bit confusing how this relates to wasmCloud / Cosmonic projects. This [HN comment](https://news.ycombinator.com/item?id=36056311) asks a question, answered by OCaps expert. In [wasmCloud](https://wasmcloud.com) the cryptography is handled by the tooling. For Capabilities you need [Claims](https://wasmcloud.com/docs/hosts/security#claims) that are packaged as a JWT. You define the namespaced capabilities yourself, and they become part of the `wasmcloud.yaml` of your actor app. You have fine control of what it means when a capability is present, as the capability is defined by its interface (contract based programming). If you expose a `key value store` to your app, in production that can mean _any_ KV store implementation is invoked, shielded behind the interface. - [Spritely Goblins](https://spritelyproject.org/#goblins) will move to Wasm after their [Guile to Wasm](https://spritely.institute/news/guile-on-web-assembly-project-underway.html) runtime is ready. - [Brooklyn Zelenka](https://octodon.social/@expede), CTO/co-founder of [Fission Codes](https://fission.codes) gave an exciting Strangeloop presentation [“IPVM: Seamless Services for an Open World”](https://yewtu.be/watch?v=Z5U8JQZXABs) ([slides](https://noti.st/expede/go5vAN/ipvm-seamless-services-for-an-open-world)) how by the use of Wasm and [UCAN](https://ucan.xyz/) ocaps we can get to distributed compute (App Free Computing). (Should beware blockchain influences with Fission). #### [Concept] Visual component composition _WebAssembly Components_ are a proposed extension on Wasm, that allows _Wasm Modules_ to be encapsulated, and become composable and adaptable. The interface, imports/exports and execution environment can be described as [“WIT” Worlds](https://github.com/WebAssembly/component-model/blob/main/design/mvp/WIT.md), allow Interface-based Programming (Contract-based programming). [Fastly.com](http://Fastly.com) presented at the [Cloud Native Wasm Day Europe 2023](https://www.youtube.com/playlist?list=PLj6h78yzYM2Pdj8vnO0wfFyKcbKNy3e5j) a demo featuring a visual drawing canvas, allowing WASM components to be inserted e.g. from a component registry (a federated, distributed namespace of Wasm components), connected together with lines to satisfy import and then exported as a `.wasm` file that constitutes the composition. [![](https://discuss.coding.social/uploads/default/original/2X/4/4676abc835e2735c7b656083e449ef8b0936ef90.jpeg "Future of Component Tooling - Peter Huene & Guy Bedford, Fastly") ](https://www.youtube.com/watch?v=JCIwpc7x4jU&list=PLj6h78yzYM2Pdj8vnO0wfFyKcbKNy3e5j&t=998s) The [wasmbuilder.app](https://wasmbuilder.app/) demo is online, and Apache 2.0 [project on Github](https://github.com/peterhuene/wasmbuilder.app) in Rust + Typescript. #### [Vendor] [Cosmonic](https://cosmonic.com) WebAssembly PaaS _“From a simple idea to running your apps anywhere, at scale, in minutes, Cosmonic is the lightweight, low-boilerplate platform that radically simplifies the development lifecycle.”_ - “From Sketch to Scale” - “Any Cloud, Any Edge, At Any Scale” - “Untangle Dev and Ops” Cosmonic is a leading early adopter vendor (chairing Cloud Native Foundation). Co-maintainers of wasmCloud, which they brought into the Cloud Native Foundation, and improving compliance for. Their Paas is based on wasmCloud, but they also have several independent OSS projects. Their philosophy is to be (permissive) open-source. Key aspect in wasmCloud (which has both a Rust and Elixir impl) and Cosmonic is to _“separate business logic from non-functional requirements (NFR’s)”_ .. which nears same objective of Clean Architecture pattern’s infra layer, where Ports & Adapters are “Capability” abstractions. > **Note** : Vendor Deis Labs works on [Spiderlightning CLI](https://deislabs.github.io/spiderlightning/) to support [common Capabilities](https://github.com/deislabs/spiderlightning/blob/main/docs/primer.md), defined as WIT and tested against implementations. wasmCloud uses a bunch of standards: Open Container Initiative (OCI), Open Application Model, Cloud Events, NATS networking and Open Telemetry. Note: Cosmonic is also offering visual modeling in their tooling: [https://cosmonic.com/assets/medias/untangledevops-985a88a25c08ffa08e89f4ac185de047.mp4](https://cosmonic.com/assets/medias/untangledevops-985a88a25c08ffa08e89f4ac185de047.mp4) #### [Project] [Cosmonic Concordance](https://cosmonic.com/docs/category/concordance): Actor-based CQRS/ES > **[Verifying your browser…](https://yewtu.be/watch?v=llIiUYocYcw)** Recently Cosmonic created Apache-licensed [Concordance project](https://github.com/cosmonic/concordance) in Rust, based on wasmCloud. It is opinionated in that the core of the CQRS/ES model is entirely side-effect free. From the README: > Concordance allows you to reason about your application using the fundamental building blocks of event sourcing: > > - **Aggregates** - WebAssembly components that derive state from an event stream, validate incoming commands, and emit events in response to those commands. > - **Projectors** - WebAssembly components that _project_ read-optimized data (aka materialized views) based on streams of incoming events > - **Process Managers** - Known as _sagas_ in other paradigms, a process manager is the inverse of an aggregate: it processes inbound events and starts, advances, and stops processes by emitting the corresponding commands. > - **Stateless Event Handlers** - used for entities such as **notifiers** and **gateways** , you can build WebAssembly components that receive events on a stream and then execute whatever you choose for your business logic. > > _“Constraints liberate, liberties constrain”_ - Runar Bjarnason > > This quote is a foundational principle behind this event sourcing library. You’ll find that aggregates are unable to do anything other than return a list of events. They are unable to produce side-effects, which is a good thing™. Likewise, process managers cannot produce side-effects, they can only return a list of commands. Side-effects are explicitly forced into the perview of notifiers (stateless event handlers). _Concordance looks to be independent of the Cosmonic PaaS, but this product is also based on event sourcing internally._ Project is under heavy development. The [Bankaccount](https://github.com/cosmonic/concordance/tree/main/examples/bankaccount) example app for instance is stand-alone (had Concordance classes embedded). Article on how WIT Worlds can shield from framework impl: - [For the Wit! My First Day with Components](https://cosmonic.com/blog/engineering/for-the-wit-my-first-day-with-components) (Apr 27, 2023) #### [Concept] Cloud Development Environment (CDE) Bye bye, forge and git.. CDE’s are on the rise and offer one-stop-shop developer experiences from the browser. This is going to be a big paradigm shift. Vendors all around are jumping on the fact that software development wrt configuring, deploying, maintaining the infra and cloud have become crazy complex. WebAssembly-Everywhere offers a path to solving the infra and tooling complexity. - See: [StackBlitz](https://stackblitz.com/) Instant Dev Environments. Uses [WebContainers](https://webcontainers.io/) based on Wasm. - See: [Introducing StackBlitz Codeflow](https://stackblitz.com/codeflow) (video, 30 min.) _(FOSS is lagging behind. One-stop-shop platforms poses a threat to Free Software if it doesn’t catch up. The #forgers-guild aims to go beyond “forge federation” to “forging free software”, decentralized and scoped to Social Coding FSDL, and bring unique strengths of Free Software movement into play.)_ #### [Fediverse] DDD, AS/AP, Solid, DID/VC (OMG 😱 ) Quite unexpected finding of Naamio app for the Fediverse, based on Wasm, and developed by (mysterious) cooperative [Omnify Foundation](https://omnifi.foundation). Uses ActivityPub, DIDs, Solid, and Verifiable Credentials. ![Diagram "Modern Data Mesh Revisited", Domain-Driven Service Development](https://discuss.coding.social/uploads/default/original/1X/c94eeb8040956e907d21f8ff5148a27134acf192.png) - Source: Wasm I/O 2023 by P J Laszkowicz [“From Event-Driven to Automotive”](https://yewtu.be/watch?v=-Xz3tyxm-RU) (video, [slides](https://wasmio.tech/docs/sessions/event-driven-to-automotive-wasmio23.pdf)). > **Note** : Uses combination of Wasm (fine-grained composition) and gRPC (system orchestration). #### [Concept] Universal plugin models The BSD3-Clause project [Extism: The Universal Plugin System](https://extism.org/) right now offers integrations for 15 languages and the web browser. Their goal is _to make all software programmable_, and their plugin system lends sandboxed polyglot support for that. Integration requires a Host SDK and then Plugin Development Kits (PDK’s) in your language to quickly write plugin code. **Example** : Elixir Game Server + Extism plugin integration. ![GameBox conceptual architecture diagram](https://discuss.coding.social/uploads/default/original/1X/acb7b93377fa431d3518fdd54e330ab9237bbb3f.webp) Elixir’s actor model handles real-time user interactions playing in a “game arena” via PubSub in Phoenix LiveView, while the games can be written in any language that’s supported by Extism. - See: [Elixir GameServer with Extism](https://extism.org/blog/extending-fly-io-distributed-game-system-part-1/) ([GameBox live demo](https://yewtu.be/watch?v=pIcnh4Sl_xU) at Wasm I/O), [GameBox](https://gamebox.fly.dev/) live. - See also: [Suborbital](https://suborbital.dev/) Make your SaaS application extensible for developers. (different take) - See also: The [Hashicorp go-plugin](https://github.com/hashicorp/go-plugin) ported to Wasm: [go-plugin](https://github.com/knqyf263/go-plugin) project. - Plugins in Wasm (polyglot, size-efficient, memory-safe, sandboxed and portable). - Plugin communication to host compatible with Hashicorp (gRPC-based + Protocol buffers). - See also: [Zellij](https://zellij.dev/) terminal workspace with Wasm/WASI-based plugin system in Rust. - _(OT related: [💡 Elevate Your Plugin Development with Hook-Driven-Development](https://marcuskober.com/elevate-your-plugin-development-with-hook-driven-development/))_ #### [Concept] Erlang/OTP concurrency on Rust [Lunatic Solutions](https://lunatic.solutions) offers a wasm-based Erlang/OTP-like actor model implementation in native Rust. > **[Verifying your browser…](https://yewtu.be/watch?v=HdWEA_erA6w)** > Lunatic combines the fault-tolerance and massive concurrency of Erlang with the capability-based security of WebAssembly, it creates a powerful programming model. > > Lunatic is a [single executable](https://github.com/lunatic-solutions/lunatic/releases) and runs on Windows, macOS and Linux. It spawns lightweight processes from WebAssembly modules that have their own heap/stack. These processes are preemptively scheduled on a multi-threaded executor. #### [Concept] Rust-based Web UI Great [comparison of emerging Rust-based GUI approaches](https://monadical.com/posts/shades-of-rust-gui-library-list.html) (see also: [HN Discussion](https://news.ycombinator.com/item?id=35722681), 268 comments) [Leptos: Build Fast Web applications with Rust](https://github.com/leptos-rs/leptos) is a reactive web framework most similar to [SolidJS](https://www.solidjs.com/) and [Sycamore](https://sycamore-rs.netlify.app/) (Rust) and with inspirations from other popular libs. See the [Online Book](https://leptos-rs.github.io/leptos/) (In progress). Looks properly usable. Following demo shows some development with TailwindCSS in Rust: > **[Verifying your browser…](https://yewtu.be/watch?v=ie13kswrWu4)** While Leptos has the more modern approach to Web Design, there’s a more popular web framework in Rust that supports WebAssembly, which is: - [Yew](https://yew.rs/): A framework for creating reliable and efficient web applications. Yew is set up more as a React-like framework that is diffing the DOM. #### [Innovation] [Makepad](https://github.com/makepad/makepad) Modern GUI’s in Rust Though related to the UI topic above this one, Makepad deserves a place of its own. A seriously impressive work in Rust where complex GUI’s are defined by a Figma-like DSL with background code support. It is an effort to bring Coders and Designers closer together. Wasm/WebGL is one of their compilation targets. 👉 This hints at a paradigm beyond the browser straitjacket, moving away from Web 2.0! Seriously consider watching this video, where the slides are done with Makepad and run real-time multiple applications within it at 120 fps.. > **[Verifying your browser…](https://yewtu.be/watch?v=rC4FCS-oMpg)** One very cool aspect re:Floorplanner is that with Makepad both the IDE and the GUI design can travel within the app itself and be live-coded and changed. Downside: No a11y support (I filed [an issue](https://github.com/makepad/makepad/issues/196)). #### [Bounded context] Diagramming ![Bounded context diagram for Social Experience Design](https://discuss.coding.social/uploads/default/original/1X/d8ef505d7564dda4c3769451e9ba6cd22a7f45bb.png) I found one Yew project (no longer maintained), called [yew-flow](https://github.com/nilaysavant/yew-flow) (see [demo](https://yew-flow.netlify.app/)), which was an attempt to port [React Flow](https://reactflow.dev/) - best candidate for integration in Floorplanner thus far - and offer that as a Wasm module. This may not be the best approach.. I am thinking more in the line of: Code that wraps any NPM project into a Wasm module or - better - component. A WIT-based component interface would be exposed and allow for different diagram type defitions to be fed to the component, and domain-specific diagram output to be fed back. #### [Innovation] [Freenet](https://freenet.org/) Rebooting _( **Update** : [Freenet.org](http://Freenet.org) is not really a reboot, rather a hostile fork by the founder against the community)_ [Freenet.org](http://Freenet.org) started in 1999 and was quite popular for a time and still going today ([Wikipedia](https://en.wikipedia.org/wiki/Freenet)). In 2023 the community started a new project called [Locutus](https://github.com/freenet/locutus) in Rust ([Matrix chatroom](https://matrix.to/#/#freenet-locutus:matrix.org)): > Freenet 2023, also known as Locutus, is a fully decentralized, peer-to-peer network and a drop-in replacement for the world wide web. It operates as a global shared computer, providing a platform for sophisticated decentralized software systems. Locutus allows developers to create decentralized alternatives to centralized services, including messaging, social media, email, and e-commerce. It’s designed for simplicity and flexibility and can be used seamlessly through your web browser. The platform’s user-friendly decentralized applications are scalable, interoperable, and secured with cryptography. > Locutus is a decentralized key-value database. It uses the same [small world](https://freenetproject.org/assets/papers/lic.pdf) routing algorithm as the original Freenet design, but each key is a cryptographic contract implemented in [Web Assembly](https://webassembly.org/), and the value associated with each contract is called its _state_. The role of the cryptographic contract is to specify what state is allowed for this contract, and how the state is modified. Freenet (or similar concept) might have a [role in Prosperity Guilds as a backbone](https://discuss.coding.social/t/small-world-networking-backbone-to-prosperity-guilds/374) (just an idea). #### [Showcase] Wordpress Playground Automattic launched an official [Wordpress Playground](https://developer.wordpress.org/playground) that runs a full Wordpress server entirely in the browser based on WebAssembly. Discussed on HN [in this submission](https://news.ycombinator.com/item?id=36726593). > ### The operating system of the web – on your device > > Web browsers are just the beginning – WordPress Playground works in Node.js, mobile apps, VS Code, and more. Whether you want to build a note-taking application for mobile devices, an automated testing environment, or demo a live WooCommerce store on your site – Playground will support you. > > How is this possible? Playground uses the latest, cutting-edge technologies to make the key WordPress dependencies work in JavaScript. > > - [PHP runs as a WebAssembly binary](https://wordpress.github.io/wordpress-playground/docs/architecture/wasm-php-overview) > - MySQL is replaced for SQLite via a [WordPress plugin](https://github.com/WordPress/sqlite-database-integration/) > - Web server is implemented in JavaScript [as a Service Worker](https://wordpress.github.io/wordpress-playground/docs/architecture/browser-service-workers) #### [Project] [VectorVisor](https://github.com/SamGinzburg/VectorVisor) in Rust _VectorVisor is a vectorizing binary translator for GPUs, designed to make it easy to run many copies of a single-threaded WebAssembly program in parallel using GPUs._ > "GPU programming models offer a level of abstraction that is either too low-level (e.g., OpenCL, CUDA) or too high-level (e.g., TensorFlow, Halide), depending on the language. Not all applications fit into either category, resulting in lost opportunities for GPU acceleration. > > VectorVisor is a vectorized binary translator which remedies this issue by taking in existing single-threaded WebAssembly programs and running many copies of them using a GPU." #### [Product] [Nginx Unit](https://unit.nginx.org/) Universal Web App Server _NGINX Unit is a lightweight and versatile application runtime that provides the essential components for your web application as a single open-source server: running application code (including WebAssembly), serving static assets, handling TLS and request routing._ Among [key features](https://unit.nginx.org/keyfeatures/) is WebAssembly support that allows running any Wasm modules/components on the server. #### [Product] [Ambient](https://ambient.run/about) Game Engine _Game engine built with Rust, WebAssembly and WebGPU. Our WASM use is innovative; it is being used as both a sandboxed runtime for user code, and as a way to run the entire Ambient runtime in the browser. This, paired with our ECS data model, enables a highly modular architecture that allows other developers to make isolated packages (code, 3D models, tools, etc.) that they can add as a mod to your game._ The use of wasm in combination with the [Entity Component](https://en.m.wikipedia.org/wiki/Entity_component_system) System may be very flexible in App Free Computing component-oriented social experiences (e.g. modular UX/UI). - See also [HN discussion](https://news.ycombinator.com/item?id=37764133) and [Platform blog + video presentation](https://ambient.run/blog/platform). - [Bevy](https://github.com/bevyengine/bevy) is another data-driven game engine in Rust, also ECS-based with Wasm support. [@enhance\_dev](https://fosstodon.org/@enhance_dev) is on the Fediverse. #### [Product] [Enhance WASM](https://enhance.dev/): Vendor-neutral server-side rendering Web Components _Enhance WASM is bringing server side rendered web components to everyone. Author your components in friendly, standards based syntax. Reuse them across multiple languages, frameworks, and servers. Upgrade them using familiar client side code when needed._ Read: [Introducing Enhance WASM](https://begin.com/blog/posts/2024-04-08-introducing-enhance-wasm). The idea to package SSR-rendered WebComponents into WebAssembly modules is appealing. #### [Project] [FluentCI Engine](https://github.com/fluentci-io/fluentci-engine): Programmable CI/CD engine without Containers _FluentCI Engine is a programmable CI/CD engine that is designed to be simple, flexible, and easy to use. It is supposed to run on the host machine without containerization or virtualization, and it is designed to be used with [Nix](https://nixos.org), [Pkgx](https://pkgx.sh), [Devbox](https://www.jetpack.io/devbox/), [Flox](https://flox.dev), [Devenv](https://devenv.sh), [EnvHub](https://github.com/tsirysndr/envhub), [Pixi](https://pixi.sh/) and [Mise](https://mise.jdx.dev/)._ MPL-2.0 licensed. Implemented in Rust/Typescript and using WebAssembly-based plugin system, based on [Extism](https://github.com/extism/extism/discussions/684#discussioncomment-9072628). > ### Features > > - Simple and easy to use > - Flexible > - No containerization or virtualization > - Built-in support for Nix, Pkgx, Devbox, Flox, Devenv, Envhub, Mise and Pixi > - Cache support (backends: local, S3, GCS, R2) > - SDK for writing pipelines in TypeScript, see [@fluentci/sdk](https://github.com/fluentci-io/fluentci-engine/blob/main/sdk/typescript) > - GraphQL API, see [API Documentation](https://github.com/fluentci-io/fluentci-engine/blob/main/docs/api.md) > - OpenTelemetry tracing > - Plugin system in WebAssembly, see [examples](https://github.com/fluentci-io/fluentci-engine/blob/main/examples) ![Code snippet in Rust invoking a pipeline via the plugin system](https://discuss.coding.social/uploads/default/original/1X/3402a93ada73173b6a8226350e23f6ef87220aac.png) #### [Project] Wikimedia [Wikifunctions](https://www.wikifunctions.org/wiki/Wikifunctions:Main_Page) _Wikifunctions is a Wikimedia project for everyone to collaboratively create and maintain a library of code functions to support the Wikimedia projects and beyond, in the world’s natural and programming languages._ Via [announcement on Mastodon](https://wikis.world/@wikifunctions/113408725127371256) their newsletter reads: > [Wikifunctions:Status updates/2024-11-01](https://www.wikifunctions.org/wiki/Wikifunctions:Status_updates/2024-11-01): The immediate work surrounds how we might better interact with WebAssembly (WASM). Almost precisely one year ago, we [announced](https://meta.wikimedia.org/wiki/Abstract_Wikipedia/Updates/2023-10-25) that we would begin running Python and JS code in WASM for its sandboxing characteristics. Since then, we have been interacting with WASM via the WebAssembly System Interface (WASI), which allows WASM commands selective access to the underlying operating system. Now they rewrite their backend to Rust to benefit from the excellent wasm tooling, which they missed for their languages JS/Node and Python at this time (1 Sept 2024). #### [Project] [EnigMatick](https://gitlab.com/enigmatick/enigmatick_wasm) ActivityPub server This project is by [Justin Thomas](https://enigmatick.social/@jdt) in Rust and GPLv3+ licensed. Justin has extended EnigMatick enough to start using it as a daily driver and dogfood during development. #### [Project] [tauri-specta](https://github.com/specta-rs/tauri-specta) / [specta-wasm-bindgen](https://github.com/oscartbeaumont/specta-wasm-bindgen) Tauri Specta will generate a [Typescript](https://www.typescriptlang.org) or [JSDoc](https://jsdoc.app) file (powered by [Specta](https://docs.rs/specta)) to provide a typesafe interface to your Tauri backend. See also on Youtube [Specta and Typescript Type Generation In Tauri](https://www.youtube.com/watch?v=EEfNfWtFn-w). ## [PGLite](https://pglite.dev/): Embeddable Postgres _Run a full Postgres database locally in WASM with reactivity and live sync._ This project is by [ElectricSQL](https://electric-sql.com/), “Build reactive, realtime, local-first apps directly on Postgres”. See also: [https://news.ycombinator.com/item?id=46146133](https://news.ycombinator.com/item?id=46146133)