6 ms·

> asm.js was Mozilla’s response to the question posed by NaCl and PNaCl: how can the web run code at native speeds? Had it been today, Chrome would have just p

by pjmlp 6mo ago

> asm.js was Mozilla’s response to the question posed by NaCl and PNaCl: how can the web run code at native speeds? Had it been today, Chrome would have just pushed NaCl and PNaCl no matter what, and then everyone would complain why Safari and Firefox aren't keeping up with "Web" standards.

xyzzy_plugh 6mo ago
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 6mo ago
  What are the key differences between PNaCl and WASM?
  - flohofwoe 6mo 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 6mo 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 6mo ago
        Indeed, NaCl and PNaCl would have been hit by Meltdown/Spectre at least as badly as SharedArrayBuffer.
        kg 6mo 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 6mo 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 6mo ago
        Wasn't pepper the P in PNaCl?
        Randomno 6mo 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 6mo 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 6mo 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 6mo 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 6mo 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 6mo 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 6mo 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 6mo 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 6mo ago
      True, it was a dead end perhaps.
  - nextaccountic 6mo ago
    Isn't this approximately just wasm?
    - projektfu 6mo ago
      Is there hardware that executes WASM directly?
- kettlecorn 6mo ago
  What do you feel is immature in the WASM ecosystem right now?
  - jauntywundrkind 6mo 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 6mo 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 6mo 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 6mo 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...
  - 6mo ago
- doctorpangloss 6mo 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 6mo 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 6mo 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 6mo 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 6mo ago
      Try a WebAssembly implementation of solitaire: https://solitaire.xaml.live/ https://solitaire.xaml.live/
    - burntcaramel 6mo 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 6mo 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 6mo 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 6mo 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 6mo 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.
lmkg 6mo ago
I mean that's still basically what they tried to do at the time. They were trying to get them through web standards committees and everything. IIRC a big reason it didn't end up working was because NaCl was such a "big" technology and asm.js such a "small" one that asm.js was able to reach production-ready first despite starting work several years later.
- pjmlp 6mo ago
  The big difference was that they lacked the market share they enjoy nowadays, with their forks and Electron crap.
- mccr8 6mo ago
  The cute thing about asm.js is that it was fully backwards compatible with the web: it was just a lot slower without dedicated support. So Epic or whomever could put out a demo that would run just fine in Chrome, but the performance was a lot worse than Firefox which had a dedicated compilation pipeline, so it made Chrome look bad.
  - JoshTriplett 6mo ago
    Exactly. "You can't not support it; you can only be slow."
- p_l 6mo ago
  The way I remember it, NaCl and PNaCl ended up nowhere not because big, but because Mozilla, then with big influence on standards, declared them not web enough for the crime of not being JavaScript and pushed against any addition of it into Gecko in any form and promoted "JavaScript is all you need" including an early demo of decoding video in JS - which I recall disgusted me because I somehow knew it would take away various technical issues preventing proprietary encoding from closing down web videos. Funnily enough, NaCl had its origins in Mozilla extension, with old versions IIRC mentioning lineage starting in Google Gears extension for Firefox
benced 6mo ago
You mean Chrome would have pushed it, Apple would have filibustered it by refusing to comment (via lack of investment in the WebKit team), and then gullible folks on the internet would defer to them. (I will note that Apple seems to have upped WebKit investment this decade since their regulatory problems started in earnest - so it's possible this would end differently today)
lern_too_spel 6mo ago
People complain when there are no highly compatible alternatives to something that would be useful to have on the web platform. Asm.js and then Wasm were those alternatives. That's why they didn't complain then but do complain now about things that Safari won't do because it would hurt the App Store. Happily, the EU is now at least trying to whip Apple into shape.
indolering 6mo ago
That's not how I remember it: it was an experiment that was useful at the time but didn't work out. It was useful internally to sandbox Flash player, but the limitations of the LLVM based approach were soon evident to everyone involved.
crabbone 6mo ago
While NaCL and Silverlight were both alternatives to Flash... All these people in comments beating their chests about how WebAssembly is totally good for everything you can imagine, and there's not a single browser game that is not a tic-tac-toe level.
musicale 6mo ago
I like how NaCl cleverly used x86 segmentation. ;-/

by pjmlp 6mo ago

xyzzy_plugh 6mo ago

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 6mo ago
What are the key differences between PNaCl and WASM?
- flohofwoe 6mo 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 6mo 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 6mo ago
      Indeed, NaCl and PNaCl would have been hit by Meltdown/Spectre at least as badly as SharedArrayBuffer.
      - kg 6mo 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 6mo 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 6mo ago
      Wasn't pepper the P in PNaCl?
      - Randomno 6mo 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 6mo 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 6mo 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 6mo 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 6mo 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 6mo 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 6mo 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 6mo 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 6mo ago
    True, it was a dead end perhaps.
- nextaccountic 6mo ago
  Isn't this approximately just wasm?
  - projektfu 6mo ago
    Is there hardware that executes WASM directly?
kettlecorn 6mo ago
What do you feel is immature in the WASM ecosystem right now?
- jauntywundrkind 6mo 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 6mo 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 6mo 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 6mo 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...
- 6mo ago
doctorpangloss 6mo 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 6mo 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 6mo 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 6mo 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 6mo ago
    Try a WebAssembly implementation of solitaire: https://solitaire.xaml.live/ https://solitaire.xaml.live/
  - burntcaramel 6mo 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 6mo 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 6mo 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 6mo 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 6mo 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.

lmkg 6mo ago

I mean that's still basically what they tried to do at the time. They were trying to get them through web standards committees and everything. IIRC a big reason it didn't end up working was because NaCl was such a "big" technology and asm.js such a "small" one that asm.js was able to reach production-ready first despite starting work several years later.

pjmlp 6mo ago
The big difference was that they lacked the market share they enjoy nowadays, with their forks and Electron crap.
mccr8 6mo ago
The cute thing about asm.js is that it was fully backwards compatible with the web: it was just a lot slower without dedicated support. So Epic or whomever could put out a demo that would run just fine in Chrome, but the performance was a lot worse than Firefox which had a dedicated compilation pipeline, so it made Chrome look bad.
- JoshTriplett 6mo ago
  Exactly. "You can't not support it; you can only be slow."
p_l 6mo ago
The way I remember it, NaCl and PNaCl ended up nowhere not because big, but because Mozilla, then with big influence on standards, declared them not web enough for the crime of not being JavaScript and pushed against any addition of it into Gecko in any form and promoted "JavaScript is all you need" including an early demo of decoding video in JS - which I recall disgusted me because I somehow knew it would take away various technical issues preventing proprietary encoding from closing down web videos. Funnily enough, NaCl had its origins in Mozilla extension, with old versions IIRC mentioning lineage starting in Google Gears extension for Firefox

benced 6mo ago

You mean Chrome would have pushed it, Apple would have filibustered it by refusing to comment (via lack of investment in the WebKit team), and then gullible folks on the internet would defer to them. (I will note that Apple seems to have upped WebKit investment this decade since their regulatory problems started in earnest - so it's possible this would end differently today)

lern_too_spel 6mo ago

People complain when there are no highly compatible alternatives to something that would be useful to have on the web platform. Asm.js and then Wasm were those alternatives. That's why they didn't complain then but do complain now about things that Safari won't do because it would hurt the App Store. Happily, the EU is now at least trying to whip Apple into shape.

indolering 6mo ago

That's not how I remember it: it was an experiment that was useful at the time but didn't work out. It was useful internally to sandbox Flash player, but the limitations of the LLVM based approach were soon evident to everyone involved.

crabbone 6mo ago

While NaCL and Silverlight were both alternatives to Flash... All these people in comments beating their chests about how WebAssembly is totally good for everything you can imagine, and there's not a single browser game that is not a tic-tac-toe level.

musicale 6mo ago

I like how NaCl cleverly used x86 segmentation. ;-/