Is JSLinux still an interpreter, or does it JIT compile these days?<p>Or are modern JS JITs so good that this is no longer a relevant distinction, i.e. is the performance of a JITted x86 interpreter effectively equivalent to a JITting x86-to-Javascript translator where the result is then itself JIT interpreted?
Out of interest I tried running my Primes benchmark [1] on both the x86_64 and x86 Alpine and the riscv64 Buildroot, both in Chrome on M1 Mac Mini. Both are 2nd run so that all needed code is already cached locally.<p>x86_64:<p><pre><code> localhost:~# time gcc -O primes.c -o primes
real 0m 3.18s
user 0m 1.30s
sys 0m 1.47s
localhost:~# time ./primes
Starting run
3713160 primes found in 456995 ms
245 bytes of code in countPrimes()
real 7m 37.97s
user 7m 36.98s
sys 0m 0.00s
localhost:~# uname -a
Linux localhost 6.19.3 #17 PREEMPT_DYNAMIC Mon Mar 9 17:12:35 CET 2026 x86_64 Linux
</code></pre>
x86 (i.e. 32 bit):<p><pre><code> localhost:~# time gcc -O primes.c -o primes
real 0m 2.08s
user 0m 1.43s
sys 0m 0.64s
localhost:~# time ./primes
Starting run
3713160 primes found in 348424 ms
301 bytes of code in countPrimes()
real 5m 48.46s
user 5m 37.55s
sys 0m 10.86s
localhost:~# uname -a
Linux localhost 4.12.0-rc6-g48ec1f0-dirty #21 Fri Aug 4 21:02:28 CEST 2017 i586 Linux
</code></pre>
riscv64:<p><pre><code> [root@localhost ~]# time gcc -O primes.c -o primes
real 0m 2.08s
user 0m 1.13s
sys 0m 0.93s
[root@localhost ~]# time ./primes
Starting run
3713160 primes found in 180893 ms
216 bytes of code in countPrimes()
real 3m 0.90s
user 3m 0.89s
sys 0m 0.00s
[root@localhost ~]# uname -a
Linux localhost 4.15.0-00049-ga3b1e7a-dirty #11 Thu Nov 8 20:30:26 CET 2018 riscv64 GNU/Linux
</code></pre>
Conclusion: as seen also in QEMU (also started by Bellard!), RISC-V is a *lot* easier to emulate than x86. If you're building code specifically to run in emulation, use RISC-V: builds faster, smaller code, runs faster.<p>Note: quite different gcc versions, with x86_64 being 15.2.0, x86 9.3.0, and riscv64 7.3.0.<p>[1] <a href="http://hoult..rg/primes.txt" rel="nofollow">http://hoult..rg/primes.txt</a>
> If you're building code specifically to run in emulation, use RISC-V: builds faster, smaller code, runs faster.<p>I don't really think this bears out in practice. RISC-V is easy to emulate but this does not make it fast to emulate. Emulation performance is largely dominated by other factors where RISC-V does not uniquely dominate.
Interesting to see the gcc version gap between the targets. The x86_64 image shipping gcc 15.2.0 vs 7.3.0 on riscv64 makes the performance comparison less apples-to-apples than it looks - newer gcc versions have significantly better optimization passes, especially for register allocation.
The RISC-V one has just never been touched since it was created in 2018.<p>> newer gcc versions have significantly better optimization passes<p>So what you're saying is that with a modern compiler RISC-V would win by even more?<p>TBH I doubt much has changed with register allocation on register-rich RISC ISAs since 2018. On i386, yeah, quite possible.
MIPS (the arch of which RISCV is mostly a copy) is even easier to emulate, unlike RV it does not scatter immediate bits al over the instruction word, making it easier for an emulator to get immediates. If you need emulated perf, MIPS is the easiest of all
That's a very small effect in the overall decoding of an instruction even in a pure interpretive emulator, and undetectable in a JIT.<p>Also MIPS code is much larger.
MIPS code is not much larger.<p>There are two interesting differences of ISA between MIPS and RISC-V: that MIPS does not have branch on condition, only on zero/non-zero and that MIPS has 16 bit immediates with appropriate sign extension (all zeroes for ORI, all ones for ANDI). The first difference makes MIPS programs about 10% larger and second difference makes MIPS programs smaller (RISC-V immediates are 11.5 bits due to mandatory sign extension, 13 bits are required to cover 95% of immediates in MIPS-like scheme), a percent or so, I think.
Entirely disagreed. In a simple step by step emulator it can be as much as 30% of the time spent. In a jit indeed it is less of an effect.
MIPS Linux ELF interpreter in Perl:<p><a href="http://blog.schmorp.de/2015-06-08-emulating-linux-mips-in-perl-1.html" rel="nofollow">http://blog.schmorp.de/2015-06-08-emulating-linux-mips-in-pe...</a>
[dead]
The thing I most want to use this (or some other WASM Linux engine) for is running a coding agent against a virtual operating system directly in my browser.<p>Claude Code / Codex CLI / etc are all great because they know how to drive Bash and other Linux tools.<p>The browser is probably the best sandbox we have. Being able to run an agent loop against a WebAssembly Linux would be a very cool trick.<p>I had a play with v86 a few months ago but didn't quite get to the point where I hooked up the agent to it - here's my WIP: <a href="https://tools.simonwillison.net/v86" rel="nofollow">https://tools.simonwillison.net/v86</a> - it has a text input you can use to send commands to the Linux machine, which is pretty much what you'd need to wire in an agent too.<p>In that demo try running "cat test.lua" and then "lua test.lua".
> The thing I most want to use this (or some other WASM Linux engine) for is running a coding agent against a virtual operating system directly in my browser.<p>That exists: <a href="https://github.com/container2wasm/container2wasm" rel="nofollow">https://github.com/container2wasm/container2wasm</a><p>Unfortunately I found the performance to be enough of an issue that I did not look much further into it.
Simon, this HN post didn't need to be about Gen AI.<p>This thing is really inescapable those days.
Parallel thread: <a href="https://news.ycombinator.com/item?id=47311484#47312829">https://news.ycombinator.com/item?id=47311484#47312829</a> - "I've always been fascinated by this, but I have never known what it would be useful for."<p>I should have replied there instead, my mistake.
I don't know man, I didn't see anyone say "this post didn't need to be about <random topic>", HN has just become allergic to LLMs lately.<p>I'm excited about them and I think discussion on how to combine two exciting technologies are exactly what I'd like to see here.
You haven't been around here in the Blockchain/NFT/Smart Contract dark ages, have you?
Naw man I just signed up.
TBH I’ve been here a while, never felt what the point with the above is but do feel LLM:s are a new valuable affordance in computer use.<p>I mean I don’t have to remember the horrible git command line anymore which already improves my exprience as a dev 50%.<p>It’s not all hype bs this time.
> I mean I don’t have to remember the horrible git command line anymore<p>Every time I see a comment like this, I have to wonder what the heck other devs were doing. Don’t you know there were shell aliases, and snippet managers, and a ton of other tools already? I never <i>had to</i> commit special commands to memory, and I could always reference them faster than it takes to query any LLM.
Has there ever been any other topic that was not only the subject of the majority of submissions, but also had a subset of users repeatedly butting into completely unrelated discussions to go "b-but what about <thing>? we need to talk about <thing> here too! how can I relate this to <thing>? look at my <thing> product!"?<p>You can't just roll in to a random post to tell people about your revolutionary new AI agent for the 50th time this week and expect them not to be at least mildly annoyed.
I'm with you, but he wasn't telling us about his agent, he was saying "this is a cool technology and I've been wanting to use it to make a thing". The thing just happened to be LLM-adjacent.
[dead]
What topics are allowed in your opinion? I very much enjoyed Simon’s comment as it is a use case I also was thinking of.
Why not leting upvotes do their thing? I enjoyed this comment.
a bit cute that you interacted with the 1 AI thread. there are other threads!
Check out Jeff Lindsay's Apptron (<a href="https://github.com/tractordev/apptron" rel="nofollow">https://github.com/tractordev/apptron</a>), comes very close to this, and is some great tech all on its own.
It's getting there. Among other things, it's probably the quickest way to author a Linux environment to embed on the web:
<a href="https://www.youtube.com/watch?v=aGOHvWArOOE" rel="nofollow">https://www.youtube.com/watch?v=aGOHvWArOOE</a><p>Apptron uses v86 because its fast. Would love it for somebody to add 64-bit support to v86. However, Apptron is not <i>tied</i> to v86. We could add Bochs like c2w or even JSLinux for 64-bit, I just don't think it will be fast enough to be useful for most.<p>Apptron is built on Wanix, which is sort of like a Plan9-inspired ... micro hypervisor? Looking forward to a future where it ties different environments/OS's together.
<a href="https://www.youtube.com/watch?v=kGBeT8lwbo0" rel="nofollow">https://www.youtube.com/watch?v=kGBeT8lwbo0</a>
We are working on exactly this: <a href="https://browserpod.io" rel="nofollow">https://browserpod.io</a><p>For a full-stack demo see: <a href="https://vitedemo.browserpod.io/" rel="nofollow">https://vitedemo.browserpod.io/</a><p>To get an idea of our previous work: <a href="https://webvm.io" rel="nofollow">https://webvm.io</a>
I run agents as a separate Linux user. So they can blow up their own home directory, but not mine. I think that's what most people are actually trying to solve with sandboxing.<p>(I assume this works on Macs too, both being Unixes, roughly speaking :)
Are you describing bolt.new? (Unfortunately, it looks like their open source project is lagging behind <a href="https://github.com/stackblitz-labs/bolt.diy" rel="nofollow">https://github.com/stackblitz-labs/bolt.diy</a>)
> The thing I most want to use this (or some other WASM Linux engine) for is running a coding agent against a virtual operating system directly in my browser.<p>Well, there it is, the dumbest thing I'll read on the internet all week.<p>Most of the engineering in Linux revolves around efficiently managing hardware interfaces to build up higher-level primitives, upon which your browser builds even higher-level primitives, that you want to use to simulate an x86 and attached devices, so you can start the process again? Somewhere (everywhere), hardware engineers are weeping. I'll bet you can't name a single advantage such a system would have over cloud hosting or a local Docker instance.<p>Even worse, you want this so your cloud-hosted imaginary friend can boil a medium-sized pond while taking the joyful bits of software development away from you, all for the enrichment of some of the most ethically-challenged members of the human race, and the fawning investors who keep tossing other people's capital at them? Our species has perhaps jumped the shark.
While this may be a better sandbox, actually having a separate computer dedicated to the task seems like a better solution still and you will get better performance.<p>Besides, prompt injection or simpler exploits should be addressed first than making a virtual computer in a browser and if you are simulating a whole computer you have a huge performance hit as another trade off.<p>On the other hand using the browser sandbox that also offers a UI / UX that the foundation models have in their apps would ease their own development time and be an easy win for them.
It's relatively easy to spin up a busybox WASM v86 solution
This is not the technical solution you want, but I think it provides the result that you want: <a href="https://github.com/devcontainers" rel="nofollow">https://github.com/devcontainers</a><p>tldr; devcontainers let you completely containerize your development environment. You can run them on Linux natively, or you can run them on rented computers (there are some providers, such as GitHub Codespaces) or you can also run them in a VM (which is what you will be stuck with on a Mac anyways - but reportedly performance is still great).<p>All CLI dev tools (including things like Neovim) work out of the box, but also many/most GUI IDEs support working with devcontainers (in this case, the GUI is usually not containerized, or at least does not live in the same container. Although on Linux you can do that also with Flatpak. And for instance GitHub Codespaces runs a VsCode fully in the browser for you which is another way to sandbox it on both ends).
This is interesting (and I've seen it mentioned in some editors), but how do I use it? It would be great if it had bubblewrap support, so I don't have to use Docker.<p>Do you know if there's a cli or something that would make this easier? The GitHub org seems to be more focused on the spec.
[flagged]
Sorry for the off-topic, but what a bliss to see Windows 2000 interface. And what an absolute abomination from hell pretty much all the modern UIs are.
My god that interface feels like home.
Yeah. Microsoft really went downhill UI-wise.
win2000 brings back so many good memories.
Is that even remotely relevant to JSLinux?
Yes, it's one of the available emulated systems on JSLinux.
If you'd clicked the link, instead of just reading the title, you'd have known it was.
Unfortunately, he didn't attach the source code for the 64-bit x86 emulation layer, or the config used to compile the hosted image.<p>For a more open-source version, check out container2wasm (which supports x86_64, riscv64, and AArch64 architectures): <a href="https://github.com/container2wasm/container2wasm" rel="nofollow">https://github.com/container2wasm/container2wasm</a>
<a href="https://github.com/copy/v86" rel="nofollow">https://github.com/copy/v86</a> might be a more 1:1 fully open sourced alternative.
"he didn't attach the source code for the 64-bit x86 emulation layer"<p>It's not open source? If that's the case, it should be in his FAQ.
Wow, with AVX512 too?? Now I really want to add it to QEMU. :)<p>(For APX I have patches at <a href="https://lore.kernel.org/qemu-devel/20260301144218.458140-1-pbonzini@redhat.com/T/" rel="nofollow">https://lore.kernel.org/qemu-devel/20260301144218.458140-1-p...</a> but I have never tested them on system emulation).
Amazing work by Fabrice Bellard as always. The x86_64 support opens up so many possibilities for running modern Linux distributions in the browser.
If anyone is interested, I made some modifications last month to get TempleOS running on the x86_64 JSLinux: <a href="https://ring0.holyc.xyz/" rel="nofollow">https://ring0.holyc.xyz/</a>
Wow, thanks for this, this is exactly what v86 was missing!
Runs faster than my demo: <a href="https://zb3.me/qemu-wasm-test/jspi-noffi/" rel="nofollow">https://zb3.me/qemu-wasm-test/jspi-noffi/</a><p>Even though it has no JIT. Truly magic :)
I've been using the x86_64 Alpine jslinux browser image in Chrome for the last 4 hours - pulling code down via git, building several large packages from source, editing and altering code, and running their test suites. This VM may be 50 times slower than native, but it is rock solid - worked perfectly and is stable. It's simply remarkable.
I am almost sure it was done so carefully that you can extract it from the abominations which are the whatng cartel web engines with a direct to OS abstraction layer that with only some little amount of work.
Incredible guy!
I love how nonchalantly demonstrates his custom terminal emulator and javascript engine.
I can launch this thing and start making arbitrary connections out to port 25 on the internet from some random IP? Hmm.
From the "Technical notes" page:<p>> Access to Internet is possible inside the emulator. It uses the websocket VPN offered by Benjamin Burns (see his blog). The bandwidth is capped to 40 kB/s and at most two connections are allowed per public IP address. Please don't abuse the service.<p><a href="https://bellard.org/jslinux/tech.html" rel="nofollow">https://bellard.org/jslinux/tech.html</a>
A somewhat better solution via tailnet you can find in <a href="https://webvm.io/" rel="nofollow">https://webvm.io/</a>
how can I install a openclaw in the jslinux.
I've always been fascinated by this, but I have never known what it would be useful for. Does anyone know of any practical use cases?
I use bellard.org/jslinux to test compilation of strange code sometimes[1], since it came with compilers that are different versions from what I have installed locally, and it's easier to open up a browser than starting a VM.<p>[1] For example:<p><a href="https://www.ioccc.org/2020/yang/index.html#:~:text=tcc%200.9.25%20on-,JSLinux,-Output%20of%20Mile" rel="nofollow">https://www.ioccc.org/2020/yang/index.html#:~:text=tcc%200.9...</a><p><a href="https://www.ioccc.org/2018/yang/index.html#:~:text=tcc%200.9.25%20on-,JS/Linux,-Nuko%20compiles%20without" rel="nofollow">https://www.ioccc.org/2018/yang/index.html#:~:text=tcc%200.9...</a>
I use a similar emulator (v86) as a way to share my hobby OS. Approximately zero people, even my friends, are going to boot my hobby OS on real hardware; I did manage to convince some of them to run it in qemu, but it's difficult. A browser environment shows the thing quite well; and easy networking is cool too.<p>My hobby OS itself is not very useful, but it's fun if you're in the right mood.
I guess for the author its learning about how Linux can be ported to the browser. For us, it's more of a nice amusement.<p>But then again, I've never understood why Buddhist monks create sand mandalas[1] and then let them be blown away (the mandalas not the monks!).<p>I think one should see it from the authors PoV instead of thinking "what is in it for me". If I were to use this, then to create digital sand mandalas in the browser! ;)<p>[1]: <a href="https://en.wikipedia.org/wiki/Sand_mandala" rel="nofollow">https://en.wikipedia.org/wiki/Sand_mandala</a>
We are a playful species. People enjoy play. If we didn't have to work for a living but still enjoyed food security that is all most of us would do. But we are also a very exploitative species, some more than others. Companies have made billions of dollars on top of Fabrice Bellard's works, qemu, ffmpeg etc.<p>These companies don't have any imagination. Their management has no vision. They could not create anything new and wonderful if they tried. People like Fabrice do and we are all richer for it. If your asking about the practical use you are likely in the exploitative mindset which is understandable on HN. The hacker/geek mindset enjoys this for what it is.
<a href="https://infinitemac.org/" rel="nofollow">https://infinitemac.org/</a> is an example of a good use: users can try out old versions of Mac OS, to see what's changed and what software used to be available for old versions. It doesn't use JSLinux, but other emulators [1]<p>[1] <a href="https://blog.persistent.info/2025/03/infinite-mac-os-x.html" rel="nofollow">https://blog.persistent.info/2025/03/infinite-mac-os-x.html</a>
Most such emulators have Internet access on the IP level. Therefore, this is a very cheap way to test anything on the Internet.<p><pre><code> apk add nmap
nmap your.domain.com
</code></pre>
However, the speed is heavily throttled. You can even use ssh and login to your own server.<p>It can also be used as a very cheap way to provide a complete build environment on a single website, for example to teach C/C++. Or to learn the shell. You don't have to install anything.
Some sort of web based archive of applications/etc where you can boot them up in your browser.
Maybe if you’ve got some ancient software that’s missing source code and only runs with X Y and Z conditions, you could continue to offer it on the web and build around it like that? Not sure if that would be practical at all, but could be interesting
Agentic workloads create and then run code. You don't want to just run that code in a "normal" environment like a container, or even a very well protected VM. There are other options, ofc - eg. gvisor, crossvm, firecracker, etc, but this one is uncommon enough to have a small number of attackers trying to hack it.
What's wrong with a well protected VM? Especially compared to something where the security selling point is "no one uses it" (according to your argument; I don't know how secure this actually is)
Obscurity is a shrinking moat unless you are upstreaming changes regularly, and most uncommon emulators lag behind on the boring but needed patches compared to QEMU or Firecracker. If you shift to a niche emulator for security, you really need a plan to audit the new attack surface it brings. Even a weird stack tends to attract attackers once it gets popular enough or just irritates someone determined.
My college professor used it to teach us the Linux command line<p>We have Windows PCs in the classroom.
How do TinyEmu and JSLinux compare to linux-wasm?<p>From "Show HN: Amla Sandbox – WASM bash shell sandbox for AI agents" (2026)
<a href="https://news.ycombinator.com/item?id=46825119">https://news.ycombinator.com/item?id=46825119</a> :<p>>>> <i>How to run vscode-container-wasm-gcc-example with c2w, with joelseverin/linux-wasm?</i><p>>> <i>linux-wasm is apparently faster than c2w</i><p>From "Ghostty compiled to WASM with xterm.js API compatibility" <a href="https://news.ycombinator.com/item?id=46118267">https://news.ycombinator.com/item?id=46118267</a> :<p>> <i>From joelseverin/linux-wasm: <a href="https://github.com/joelseverin/linux-wasm" rel="nofollow">https://github.com/joelseverin/linux-wasm</a> :</i><p>>> <i>Hint: Wasm lacks an MMU, meaning that Linux needs to be built in a NOMMU configuration</i><p>From <a href="https://news.ycombinator.com/item?id=46229385">https://news.ycombinator.com/item?id=46229385</a> :<p>>> <i>There's a pypi:SystemdUnitParser.</i>
UBY: touchscreen: How to scroll the scrollback
He builds epicness.
[dead]
[dead]