6 ms·

I still maintain the notion we're in the wrong timeline, one where PNaCl died and instead of a worthy, timely successor we end up being boiled alive in a soup o

I still maintain the notion we're in the wrong timeline, one where PNaCl died and instead of a worthy, timely successor we end up being boiled alive in a soup of Electron apps. I really thought, for a time, that we'd be doing everything in the browser. And in a way that's increasingly true, but it all just feels worse than ever. I like WASM and I want to like WASM but the rate of maturity within the ecosystem is incredibly abysmal. What's worse is that we should all be running our untrustworthy AI tools and their outputs in precisely such a sandbox, and companies are selling the reverse: hosted sandboxes, hosted JS-based VMs. I guess that was always the problem: there was never any money in a client-side sandbox.

tardedmeme 5mo ago
What are the key differences between PNaCl and WASM?
- flohofwoe 5mo ago
  There were 3 systems, all with interesting differences. The original NaCl was a 'validated subset' of native CPU machine code (e.g. actual x86 machine code with some instructions and instruction sequences disallowed which would allow to escape the sandbox). The next iteration was P(ortable)-NaCl which replaced the native machine code with a subset of LLVM bitcode, which was then compiled at load time. Unfortunately with this step NaCl lost most of its advantages. Startup time was atrocious because it was basically the second half of the LLVM compilation pipeline (from LLVM-IR to machine code). LLVM-IR also isn't actually great as CPU-agnostic bytecode. WASM was designed from the ground up as CPU agnostic bytecode that's also much easier and faster to validate. The only major advantage of PNaCl vs early WASM was that PNaCl supported shared-memory threading right from the start (this is still knee-capped in WASM because of the COOP/COEP response header requirement). ...apart from Emscripten => asm.js => WASM, and Google's NaCl/PNaCl there was also a system by Adobe (Flascc/Alchemy(?) I forgot all the names this went through) to compile C and C++ code into Adobe Flash bytecode. I have an ancient blogpost from 2012 which compares the three (and where I have been flabbergasted by how well Emscripten actually worked - and this was even before asm.js - the linked demo is unfortunately no longer up): https://floooh.github.io/2012/10/23/mea-culpa.html https://floooh.github.io/2012/10/23/mea-culpa.html
  - bawolff 5mo ago
    > The only major advantage of PNaCl vs early WASM was that PNaCl supported shared-memory threading right from the start (this is still knee-capped in WASM because of the COOP/COEP response header requirement). Presumably that is because PNaCl predated spectre (?)
    - flohofwoe 5mo ago
      Indeed, NaCl and PNaCl would have been hit by Meltdown/Spectre at least as badly as SharedArrayBuffer.
      - kg 5mo ago
        I remember early during the Wasm design process we were openly speculating whether people would eventually figure out how to do stuff like Rowhammer from raw Javascript. My bet was on Yes, but I don't remember if any of my teammates said No. I think we all knew the writing was on the wall by then.
  - Randomno 5mo ago
    > (Flascc/Alchemy(?) I forgot all the names this went through) Crossbridge was its third and most recent name. Pepper.js is another interesting project from around this time that didn't pan out. https://github.com/google/pepper.js/ https://github.com/google/pepper.js/
    - Yoric 5mo ago
      Wasn't pepper the P in PNaCl?
      - Randomno 5mo ago
        The P in PNaCl is Portable. Pepper was a pun on Native Client (since NaCl = salt). Pepper Plugin API (PPAPI) was Google's more secure version of NPAPI (Netscape Plugin API). Flash Player was essentially the only thing using NPAPI/PPAPI by the end of its life.
- mccr8 5mo ago
  One of the big issues with NaCl is that the API it used wasn't standardized at all and there was only a single implementation. You could pick a random function and ask "hey, what happens if you pass in some slightly weird arguments?" and there was no answer beyond "whatever Chrome does". With enough work, maybe that could have been overcome while preserving backwards compatibility, but there were lots of random functions in there because somebody or other had found it useful. WASM was built from the ground up with a standards process and multiple implementations.
alex7o 5mo ago
I do understand why NaCL and PNaCL are undesirable and why wasm is much better, but as a student the NaCL ssh app had saved my computer science homeworks more than once, and this is something that still doesn't have an alternative although I rarely would need it nowadays.
- ramses0 5mo ago
  https://ssheasy.com/ https://ssheasy.com/ https://www.google.com/search?q=wasm+ssh+client https://www.google.com/search?q=wasm+ssh+client ...the future is here!
  - alex7o 5mo ago
    I think the whole NaCL thing was able to do the ssh directly from the browser without any tunneling, but maybe I am misremembering
hoppp 5mo ago
Its like natural selection, maybe not the best traits win overall but one that is the most popular choice because everyone is a webdev.
projektfu 5mo ago
I wish we had another alternate timeline. "Our submission is in TALx86, a strongly typed functional language that encourages an explicit continuation-passing style and supports mutually recursive modules. We were encouraged to use this language when we learned that the competition would allow us to run our program on an interpreter implemented in hardware. We are grateful to the Intel Corporation for developing this interpreter." https://www.cs.cornell.edu/talc/icfp99-contest/solution.htm https://www.cs.cornell.edu/talc/icfp99-contest/solution.htm
- cylinder714 5mo ago
  Typed Assembly Language—fascinating. But since the software is "All rights reserved," I don't know if it can be used beyond personal use.
  - projektfu 5mo ago
    True, it was a dead end perhaps.
- nextaccountic 5mo ago
  Isn't this approximately just wasm?
  - projektfu 5mo ago
    Is there hardware that executes WASM directly?
kettlecorn 5mo ago
What do you feel is immature in the WASM ecosystem right now?
- jauntywundrkind 5mo ago
  Not the previous poster, but immatures: Needing to compile down to one enormous program, with no possible code sharing. The async story is not good. Wasm components & wasi have a lot of promise here. Until now though browsers have been ignoring all this; Firefox just started taking a more active interest. https://hacks.mozilla.org/2026/02/making-webassembly-a-first-class-language-on-the-web/ https://hacks.mozilla.org/2026/02/making-webassembly-a-first...
  - flohofwoe 5mo ago
    Probably an unpopular opinion, but IMHO the WASM Component Model is an entirely overengineered boondoggle that has no place in browsers. It's trivial to create small statically linked WASM programs in the "a few dozen kilobytes" range with the right programming language (like C). "Code sharing" via dynamic linking also works, but it has the same downsides as dynamic linking on native platforms (basically that DLL interfaces represent an optimization barrier): https://emscripten.org/docs/compiling/Dynamic-Linking.html https://emscripten.org/docs/compiling/Dynamic-Linking.html
- lenkite 5mo ago
  Kindly give us performant access to the DOM, pretty-please! WITHOUT any JS glue code. WASM is called WEB assembly but it can't access the Web API's without paying tax to the JS tyrant in between.
  - JoshTriplett 5mo ago
    > Kindly give us performant access to the DOM, pretty-please! WITHOUT any JS glue code. https://hacks.mozilla.org/2026/02/making-webassembly-a-first-class-language-on-the-web/ https://hacks.mozilla.org/2026/02/making-webassembly-a-first...
- 5mo ago
doctorpangloss 5mo ago
> we should all be running our untrustworthy AI tools and their outputs in precisely such a sandbox The DevOps infrastructure Kubernetes runbook AI inference router API people (DIK-AROUnders for short) always want an abstract technical solution that increases both their budget and their distance from the end user's actual application. Like the more money they get to dick around with meaningless technical cathedrals, the better. They're only bent out of shape that they couldn't parlay that into a sweet crypto scheme. In the real world, the line between what users actually want and what DIK-AROUnders call inauthentic activity is quite blurred. To me, the fact that AI agents can browse websites and make payments and read my email and pretend to be me or other people is a huge part of their value proposition. People want to get out of the sandbox! There are many meanings to the words security and privacy.
mmastrac 5mo ago
PNaCl was a terrible idea. It was as bad of an idea as shipping the raw sqlite interface in the browser. I feel like some of the Google-sourced standards are the laziest, least-webby ones out there. There are some good ones that come from the Chrome team, but man the real stinkers are _always_ a lazy Google engineer trying to ship a half-baked clone of something native in the browser because they need it for something or other internally.
burntcaramel 5mo ago
I’ve found canvas + WebAssembly works great together! Here’s an example of Sudoku running in WebAssembly (it was vibe coded in Zig) and then rendered to canvas. The interface between the wasm module and the browser is function calls for keyboard and mouse events, and then another that renders to a pixel buffer to copy to the canvas. https://qip.dev/play-sudoku https://qip.dev/play-sudoku And this approach also works for simple forms, such as a URL input that gets turned into a QR code. Again the interface is simple, here converted a URL into SVG markup. As you type in the input we call the WebAssembly render function again. https://qip.dev/qr https://qip.dev/qr
- dmazzoni 5mo ago
  Do you really think this "works great"? I'm using a brand-new MacBook Pro with a high-end M5 processor, and this site is extremely unresponsive for me. Huge latency between clicking and getting feedback. It also breaks accessibility. The QR code use case seems far more reasonable to me, you're generating a static image.
  - breve 5mo ago
    Try a WebAssembly implementation of solitaire: https://solitaire.xaml.live/ https://solitaire.xaml.live/
  - burntcaramel 5mo ago
    It definitely wasn’t “working great”, I’ve now fixed a bug in the event system that was causing loops. The performance should be improved now. Yes, accessibility is a key concern of mine, I’m keen to explore html-in-canvas as a way to have an accessibility tree combined with a rendered interaction. I’m personally at a stage where React and CSS have pushed to DOM to extremes of complexity and difficultly in optimization that I desire simpler ARIA-based HTML combined with custom rendering. I’m hopeful that it will be easier to test, lighter for users, and faster for everyone.
- spartanatreyu 5mo ago
  The sudoku example has something massively wrong with it's performance. Latency is over a second per click and it halts after a few clicks. The QR example works fine though
nl 5mo ago
I've been using the FileSystems API a lot lately. It gives a sandboxed directory on the local computer you can read and write to (user decides what rights you get). It's what the web version of VS Code uses to edit local files. It's wonderful. Suddenly you can blend local and remote systems together the way they should operate, without having to have local apps with god-knows-what rights. It's not implemented in Firefox. I understand it is a risky API, but wow it makes a huge difference to what is possible. For example, I did this for a recent Kaggle comp: https://github.com/nlothian/gemma-data-agent https://github.com/nlothian/gemma-data-agent It runs Gemma E4B in the browser, and Python (Pyodide) and SQL (DuckDB) in WASM. You can give it a directory with some CSVs, tell it to load them and then it can run analysis on them. The whole Web platform is great - I just wish I could say it runs in Firefox too.
breve 5mo ago
> I like WASM and I want to like WASM but the rate of maturity within the ecosystem is incredibly abysmal. The C# toolchain for WebAssembly is pretty good. You can do a lot with Avalonia and Uno: https://avaloniaui.net/ https://avaloniaui.net/ https://platform.uno/ https://platform.uno/ Here's a C# clone of Visual Basic compiled to WebAssembly: https://bandysc.github.io/AvaloniaVisualBasic6/ https://bandysc.github.io/AvaloniaVisualBasic6/
binsquare 5mo ago
i care about it more than money, here's my take on a client-side `sandbox`: https://github.com/smol-machines/smolvm https://github.com/smol-machines/smolvm it's a lightweight vm because i see sandboxing as a feature of vm's.

tardedmeme 5mo ago

What are the key differences between PNaCl and WASM?

flohofwoe 5mo ago
There were 3 systems, all with interesting differences. The original NaCl was a 'validated subset' of native CPU machine code (e.g. actual x86 machine code with some instructions and instruction sequences disallowed which would allow to escape the sandbox). The next iteration was P(ortable)-NaCl which replaced the native machine code with a subset of LLVM bitcode, which was then compiled at load time. Unfortunately with this step NaCl lost most of its advantages. Startup time was atrocious because it was basically the second half of the LLVM compilation pipeline (from LLVM-IR to machine code). LLVM-IR also isn't actually great as CPU-agnostic bytecode. WASM was designed from the ground up as CPU agnostic bytecode that's also much easier and faster to validate. The only major advantage of PNaCl vs early WASM was that PNaCl supported shared-memory threading right from the start (this is still knee-capped in WASM because of the COOP/COEP response header requirement). ...apart from Emscripten => asm.js => WASM, and Google's NaCl/PNaCl there was also a system by Adobe (Flascc/Alchemy(?) I forgot all the names this went through) to compile C and C++ code into Adobe Flash bytecode. I have an ancient blogpost from 2012 which compares the three (and where I have been flabbergasted by how well Emscripten actually worked - and this was even before asm.js - the linked demo is unfortunately no longer up): https://floooh.github.io/2012/10/23/mea-culpa.html https://floooh.github.io/2012/10/23/mea-culpa.html
- bawolff 5mo ago
  > The only major advantage of PNaCl vs early WASM was that PNaCl supported shared-memory threading right from the start (this is still knee-capped in WASM because of the COOP/COEP response header requirement). Presumably that is because PNaCl predated spectre (?)
  - flohofwoe 5mo ago
    Indeed, NaCl and PNaCl would have been hit by Meltdown/Spectre at least as badly as SharedArrayBuffer.
    - kg 5mo ago
      I remember early during the Wasm design process we were openly speculating whether people would eventually figure out how to do stuff like Rowhammer from raw Javascript. My bet was on Yes, but I don't remember if any of my teammates said No. I think we all knew the writing was on the wall by then.
- Randomno 5mo ago
  > (Flascc/Alchemy(?) I forgot all the names this went through) Crossbridge was its third and most recent name. Pepper.js is another interesting project from around this time that didn't pan out. https://github.com/google/pepper.js/ https://github.com/google/pepper.js/
  - Yoric 5mo ago
    Wasn't pepper the P in PNaCl?
    - Randomno 5mo ago
      The P in PNaCl is Portable. Pepper was a pun on Native Client (since NaCl = salt). Pepper Plugin API (PPAPI) was Google's more secure version of NPAPI (Netscape Plugin API). Flash Player was essentially the only thing using NPAPI/PPAPI by the end of its life.
mccr8 5mo ago
One of the big issues with NaCl is that the API it used wasn't standardized at all and there was only a single implementation. You could pick a random function and ask "hey, what happens if you pass in some slightly weird arguments?" and there was no answer beyond "whatever Chrome does". With enough work, maybe that could have been overcome while preserving backwards compatibility, but there were lots of random functions in there because somebody or other had found it useful. WASM was built from the ground up with a standards process and multiple implementations.

alex7o 5mo ago

I do understand why NaCL and PNaCL are undesirable and why wasm is much better, but as a student the NaCL ssh app had saved my computer science homeworks more than once, and this is something that still doesn't have an alternative although I rarely would need it nowadays.

ramses0 5mo ago
https://ssheasy.com/ https://ssheasy.com/ https://www.google.com/search?q=wasm+ssh+client https://www.google.com/search?q=wasm+ssh+client ...the future is here!
- alex7o 5mo ago
  I think the whole NaCL thing was able to do the ssh directly from the browser without any tunneling, but maybe I am misremembering

hoppp 5mo ago

Its like natural selection, maybe not the best traits win overall but one that is the most popular choice because everyone is a webdev.

projektfu 5mo ago

I wish we had another alternate timeline. "Our submission is in TALx86, a strongly typed functional language that encourages an explicit continuation-passing style and supports mutually recursive modules. We were encouraged to use this language when we learned that the competition would allow us to run our program on an interpreter implemented in hardware. We are grateful to the Intel Corporation for developing this interpreter." https://www.cs.cornell.edu/talc/icfp99-contest/solution.htm https://www.cs.cornell.edu/talc/icfp99-contest/solution.htm

cylinder714 5mo ago
Typed Assembly Language—fascinating. But since the software is "All rights reserved," I don't know if it can be used beyond personal use.
- projektfu 5mo ago
  True, it was a dead end perhaps.
nextaccountic 5mo ago
Isn't this approximately just wasm?
- projektfu 5mo ago
  Is there hardware that executes WASM directly?

kettlecorn 5mo ago

What do you feel is immature in the WASM ecosystem right now?

jauntywundrkind 5mo ago
Not the previous poster, but immatures: Needing to compile down to one enormous program, with no possible code sharing. The async story is not good. Wasm components & wasi have a lot of promise here. Until now though browsers have been ignoring all this; Firefox just started taking a more active interest. https://hacks.mozilla.org/2026/02/making-webassembly-a-first-class-language-on-the-web/ https://hacks.mozilla.org/2026/02/making-webassembly-a-first...
- flohofwoe 5mo ago
  Probably an unpopular opinion, but IMHO the WASM Component Model is an entirely overengineered boondoggle that has no place in browsers. It's trivial to create small statically linked WASM programs in the "a few dozen kilobytes" range with the right programming language (like C). "Code sharing" via dynamic linking also works, but it has the same downsides as dynamic linking on native platforms (basically that DLL interfaces represent an optimization barrier): https://emscripten.org/docs/compiling/Dynamic-Linking.html https://emscripten.org/docs/compiling/Dynamic-Linking.html
lenkite 5mo ago
Kindly give us performant access to the DOM, pretty-please! WITHOUT any JS glue code. WASM is called WEB assembly but it can't access the Web API's without paying tax to the JS tyrant in between.
- JoshTriplett 5mo ago
  > Kindly give us performant access to the DOM, pretty-please! WITHOUT any JS glue code. https://hacks.mozilla.org/2026/02/making-webassembly-a-first-class-language-on-the-web/ https://hacks.mozilla.org/2026/02/making-webassembly-a-first...
5mo ago

doctorpangloss 5mo ago

> we should all be running our untrustworthy AI tools and their outputs in precisely such a sandbox The DevOps infrastructure Kubernetes runbook AI inference router API people (DIK-AROUnders for short) always want an abstract technical solution that increases both their budget and their distance from the end user's actual application. Like the more money they get to dick around with meaningless technical cathedrals, the better. They're only bent out of shape that they couldn't parlay that into a sweet crypto scheme. In the real world, the line between what users actually want and what DIK-AROUnders call inauthentic activity is quite blurred. To me, the fact that AI agents can browse websites and make payments and read my email and pretend to be me or other people is a huge part of their value proposition. People want to get out of the sandbox! There are many meanings to the words security and privacy.

mmastrac 5mo ago

PNaCl was a terrible idea. It was as bad of an idea as shipping the raw sqlite interface in the browser. I feel like some of the Google-sourced standards are the laziest, least-webby ones out there. There are some good ones that come from the Chrome team, but man the real stinkers are _always_ a lazy Google engineer trying to ship a half-baked clone of something native in the browser because they need it for something or other internally.

burntcaramel 5mo ago

I’ve found canvas + WebAssembly works great together! Here’s an example of Sudoku running in WebAssembly (it was vibe coded in Zig) and then rendered to canvas. The interface between the wasm module and the browser is function calls for keyboard and mouse events, and then another that renders to a pixel buffer to copy to the canvas. https://qip.dev/play-sudoku https://qip.dev/play-sudoku And this approach also works for simple forms, such as a URL input that gets turned into a QR code. Again the interface is simple, here converted a URL into SVG markup. As you type in the input we call the WebAssembly render function again. https://qip.dev/qr https://qip.dev/qr

dmazzoni 5mo ago
Do you really think this "works great"? I'm using a brand-new MacBook Pro with a high-end M5 processor, and this site is extremely unresponsive for me. Huge latency between clicking and getting feedback. It also breaks accessibility. The QR code use case seems far more reasonable to me, you're generating a static image.
- breve 5mo ago
  Try a WebAssembly implementation of solitaire: https://solitaire.xaml.live/ https://solitaire.xaml.live/
- burntcaramel 5mo ago
  It definitely wasn’t “working great”, I’ve now fixed a bug in the event system that was causing loops. The performance should be improved now. Yes, accessibility is a key concern of mine, I’m keen to explore html-in-canvas as a way to have an accessibility tree combined with a rendered interaction. I’m personally at a stage where React and CSS have pushed to DOM to extremes of complexity and difficultly in optimization that I desire simpler ARIA-based HTML combined with custom rendering. I’m hopeful that it will be easier to test, lighter for users, and faster for everyone.
spartanatreyu 5mo ago
The sudoku example has something massively wrong with it's performance. Latency is over a second per click and it halts after a few clicks. The QR example works fine though

nl 5mo ago

I've been using the FileSystems API a lot lately. It gives a sandboxed directory on the local computer you can read and write to (user decides what rights you get). It's what the web version of VS Code uses to edit local files. It's wonderful. Suddenly you can blend local and remote systems together the way they should operate, without having to have local apps with god-knows-what rights. It's not implemented in Firefox. I understand it is a risky API, but wow it makes a huge difference to what is possible. For example, I did this for a recent Kaggle comp: https://github.com/nlothian/gemma-data-agent https://github.com/nlothian/gemma-data-agent It runs Gemma E4B in the browser, and Python (Pyodide) and SQL (DuckDB) in WASM. You can give it a directory with some CSVs, tell it to load them and then it can run analysis on them. The whole Web platform is great - I just wish I could say it runs in Firefox too.

breve 5mo ago

> I like WASM and I want to like WASM but the rate of maturity within the ecosystem is incredibly abysmal. The C# toolchain for WebAssembly is pretty good. You can do a lot with Avalonia and Uno: https://avaloniaui.net/ https://avaloniaui.net/ https://platform.uno/ https://platform.uno/ Here's a C# clone of Visual Basic compiled to WebAssembly: https://bandysc.github.io/AvaloniaVisualBasic6/ https://bandysc.github.io/AvaloniaVisualBasic6/

binsquare 5mo ago

i care about it more than money, here's my take on a client-side `sandbox`: https://github.com/smol-machines/smolvm https://github.com/smol-machines/smolvm it's a lightweight vm because i see sandboxing as a feature of vm's.