The trend is real. It rests on a handful of projects, not on one Chrome or WebAssembly release. A MakeUseOf feature by Yadullah Abidi made the case on November 17, 2026. This piece checks each claim against the projects' own documentation. Several details in that feature need qualifying.
What WebAssembly does
WebAssembly, or Wasm, is a low-level bytecode format. MDN describes it as a compilation target for languages such as C, C++ and Rust. It is meant to complement JavaScript, not replace it.
MDN lists several limits that matter here:
- WebAssembly is specified to run in a sandboxed execution environment, and like other web code it is subject to the browser's same-origin and permissions policies. That wording comes from the MDN concepts page in the source packet, and the first sentence is paraphrased from it. The same page says Wasm cannot currently touch the DOM directly. It calls JavaScript, which then makes the Web API call.
- "Near-native" is a design goal, not a promise. How close a port gets depends on the workload.
- Emscripten, the common C/C++ route, ships JavaScript glue code. That code maps libraries such as SDL and OpenGL onto browser APIs.
This is the difference between a runtime and an operating system. A Wasm app can bring a lot of existing code to the web. It still has to ask the browser for files, graphics, audio and networking.
Heavy software in a tab
PlayStation 2 emulation: TabStationToo
TabStationToo's repository calls the project early and experimental. It compiles the PCSX2 emulator to WebAssembly. It is independent of PCSX2 and Sony. You supply your own BIOS and disc images, and the project says nothing is uploaded.
The project README says PCSX2's recompilers write x86 or ARM code, which a browser cannot run. TabStationToo therefore has its own JITs for the main CPU, I/O CPU and vector units. These compile to Wasm modules at run time.
That differs from the MakeUseOf summary. The feature says the port falls back on interpreters and a software renderer, with WebGPU only planned. The README describes something more advanced:
- A WebGPU hardware renderer, with software rendering as a fallback.
- Threads backed by SharedArrayBuffer.
- A page served in a cross-origin isolated context.
The README reports that games boot and that many scenes run near full speed in Chrome. It names a Ryzen 7 7840U laptop for heavy scenes. These figures are the developer's own and are not independent benchmarks. The project may also have changed since MakeUseOf wrote about it, so treat the project page as the more current source.
Two practical notes come from the README:
- On Linux, Chromium browsers keep WebGPU off for most GPUs, so the page falls back to software drawing.
- Opening index.html from disk does not work. The threads need a cross-origin isolated page.
Linux and old operating systems: v86 and WebVM
v86 emulates an x86-compatible CPU and hardware. It translates machine code to WebAssembly at runtime. Its readme says Linux works pretty well, with limits:
- 64-bit kernels are not supported.
- Multicore and 64-bit extensions are listed as missing.
- Ubuntu and other Debian derivatives work only up to the last releases that supported i386.
The same readme lists Windows 1.01, 95, 98, 2000 and ReactOS among its demos. So the browser can also act as a retro-OS museum.
WebVM works differently. CheerpX describes itself as a library for client-side execution of x86 binaries. Its networking documentation explains the main constraint. Browsers do not expose raw TCP and UDP sockets, and fetch is bound by cross-origin rules. Networking therefore goes through Tailscale, which tunnels over WebSockets.
An exit node is needed only if the VM must reach the wider internet. WebVM-to-WebVM or private-network traffic does not need one.
DOS software: js-dos
The Em-DOSBox readme notes that saved games go into an in-memory filesystem by default. They are lost when the page closes. Running in a tab does not mean your data persists.
Everyday tools
- Photopea says it runs on your device and uploads none of your files. It also says you can load it, disconnect, and keep working offline. MakeUseOf notes that Photopea's documentation requires both JavaScript and WebAssembly, so calling it a Wasm app oversimplifies things. I could not verify that requirement in the Photopea page captured here.
- Squoosh uses codecs compiled to Wasm, so it can offer formats beyond what the browser supports. Compression happens locally.
- vscode.dev is a lightweight editor. Microsoft's documentation says the web version lacks the desktop terminal and debugger. Only a subset of extensions run there. For full execution you need desktop VS Code, Codespaces or Remote Tunnels.
For Windows and developer readers, vscode.dev is the cleanest example of the limits. The interface is familiar, but the execution environment is not the desktop one.
Local AI: WebLLM
The WebLLM paper describes an OpenAI-style API that uses WebGPU for local GPU acceleration and WebAssembly for CPU computation. The MLC team's blog post adds that the engine runs WebGPU kernels for the heavy math and uses WebAssembly for non-kernel functions. The repository says structured JSON generation is implemented in the WebAssembly portion of the model library.
Performance claims need care:
- The authors' abstract says WebLLM can retain up to 80% of native performance on the same device.
- That comparison was run on an Apple MacBook Pro M3 Max, not a typical Windows PC.
- Windows results will depend on your GPU, drivers and browser WebGPU support.
An independent 2026 paper on browser-based privacy tools gives a sense of the download cost. It puts model weights at roughly 1 GB for small quantized models and 8 GB or more for larger ones. The same paper notes that once weights are cached, such an app can run without network access. Local inference is therefore real, but you pay for it in disk and GPU resources up front.
Privacy needs a caveat too. Local inference means the model runs on your machine. It does not tell you what the surrounding website does with your data. Judge each app separately.
A checklist before swapping a desktop app for a tab
- Where does the work run? Check whether it executes locally or on a server.
- What gets downloaded? Disk images, model weights and codecs can be large.
- Does your work persist? js-dos defaults to in-memory saves. TabStationToo keeps saves in browser storage or in files on disk, depending on the browser.
- Which browser features are required? WebGPU and cross-origin isolation can both gate an app.
- Does networking need extra infrastructure? WebVM relies on Tailscale.
- What is missing? Terminals, debuggers, peripherals and full OS compatibility are the usual gaps.
Verdict
"Chrome is becoming an operating system" is a catchy headline, but the evidence supports a narrower claim. The browser is becoming a broad application runtime. The sandbox and permission model are what keep it from being an OS.
The operating system still manages the hardware, the drivers and the GPU that these apps depend on. That includes the Windows driver stack behind WebGPU. Wasm also isn't unique to Chrome. TabStationToo's README says it works in Chrome and Edge, and that Firefox works too.
For IT administrators, the practical effect is that heavy workloads can now run from a URL. That makes browser policy, extension control and data-handling reviews more relevant. Which of these tools you trust comes down to what each one actually does with your files and data.
References
- WebAssembly is turning Chrome into something closer to an operating system MakeUseOf · 2026-11-17T15:01:17+00:00
- GitHub - TabStationToo/TabStationToo: TabStationToo - PS2 emulation in the browser: PCSX2 compiled to WebAssembly. · GitHub github.com
- WebAssembly concepts - WebAssembly | MDN developer.mozilla.org