jor1k

This is exactly what [0] does. Try it out. If you know the IP you can even log in to another open browser window via telnet. [0] https://github.com/s-macke/jor1k

That’s fast. Buggy, but fast. I’m totally impressed! Especially because I researched the necessary steps to do the same thing 10 years ago based on [0]. The patches required for this hack touch LLVM, libc, Linux kernel, BusyBox, ... and total approximately 15,000 lines of code. I ran a small performance test with 'bc -lq' and compared with [0]: scale=1000 4*a(1) This WASM architecture compilation completely blows away my old emulation setup, which only managed around 200 MIPS. Maybe this approach can be generalized. Running a full Linux distribution at near-native speed right in the browser would be awesome. [0] https://github.com/s-macke/jor1k

This emulator does basically the same but is much more speed optimized. It uses the OpenRISC architecture and even has networking. For what do you want to use such an emulator? [0] https://github.com/s-macke/jor1k

If the title is true, that would be a huge achievement. Unfortunately, the page says nothing about how it works and nothing about the speed advantage you get. For my emulator jor1k [1] I tried something similar years ago [2]. However I haven't continued on this topic because of priority shifts. But the potential speed advantages are astonishing. My proof of context reached more than 1 billion emulated machine instructions per second. [1] https://github.com/s-macke/jor1k [2] https://github.com/s-macke/jor1k/wiki/Breaking-the-1-billion...

That's exactly what I was thinking when I tried a more theoretical approach to my web emulator. I wrote a little about my approach in the Wiki [1]. Definitely one of my worst hacks :-) . Unfortunately the demo doesn't work anymore. I need to find out why. [1] https://github.com/s-macke/jor1k/wiki/Breaking-the-1-billion...

Try https://github.com/copy/v86 and https://github.com/s-macke/jor1k/ The latter one even has complete network support.

Just take a look at the link to the third talk I gave a few days ago about jor1k. https://github.com/s-macke/jor1k/wiki/Technical-details This talk give a few details about time frames and what someone has to do to emulate such a machine. If it is just about booting Linux you can do it in around 2000 lines (first commit of jor1k) if you take an easy architecture such as OpenRISC. Take a look at slide no. 10 and you might get an idea about the complexity of the other architectures. Slight 15 and 16 give you an idea why OpenRISC can be emulated much faster than any other architecture. A downside of such an non-mainstream CPU is less support. Indeed as Benjamin said, at least 50% of the time went into bugfixing and enhancing the toolchain. In the end the MIPS architecture might be optimal for a fast emulation and a well maintained toolchain.

Poorly, see https://github.com/s-macke/jor1k/wiki/Benchmark-with-other-e... Primarily due to the use of asm.js. I intend to implement a JIT similar to QEMU's tcg as soon as Web Assembly supports it: https://github.com/WebAssembly/design/blob/master/FutureFeat...

Depending what you want to do, there is also the OR1K Emulator running Linux - http://jor1k.com and a generic x86 emulator - v86 - https://github.com/copy/v86 you can check a small benchmark here: https://github.com/s-macke/jor1k/wiki/Benchmark-with-other-e... via https://news.ycombinator.com/item?id=10498305

Did you know, that he rewrote his code to support asm.js lately. Fabrice Bellard asked me to update my small benchmark. https://github.com/s-macke/jor1k/wiki/Benchmark-with-other-e...

Author of the repo here. I didn't expect to see this come up again, it was a weekend project done years ago while I was studying x86 internals and emulation. There are much cleaner emulators to study in JS: for the x86 family, I recommend v86 https://github.com/copy/v86 For general emulation, RISC architectures are much simpler to understand, jor1k https://github.com/s-macke/jor1k performs very well, and can simulate the OpenRISC 1000 architecture as well as RISC-V (32bit only). There's also the 64bit ANGEL emulator for RISC-V http://riscv.org/angel/ All of these are probably more useful pedagogically than my hand-unrolled jslinux repo, unless you're particularly interested in that emulator. I would love to see such js emulators one-day used in operating-systems courses, allowing one to step through bootloaders and kernel init code to g

Well, just look at these lines of code: https://github.com/s-macke/jor1k/tree/master/js/worker/or1k/... I tried something like this already. I mean to recompile parts of the code into Javascript. In my test cases the speed benefit was a factor of two or three. However in the real world, it was around a factor of two slower for different reasons. 1. The heuristic to find code chunks, which are good to recompile takes a lot of time and memory. 2. To stay on the safe side I can only recompile from jump to jump like QEMU does. Anything else would mean a much more complicated heuristic and recompilation which would beat the complexity of QEMU. 3. asm.js code runs through an foreign function interface. That means, you have to stay very long in the asm.js styled code that it is worthwhile. I got a drop of a factor of 10 in speed when I try to co

Thanks. I have made my own small list of emulators a while ago: https://github.com/s-macke/jor1k/wiki/Similar-emulators-writ... It looks like you covered them all (except maybe http://schweigi.github.io/assembler-simulator/ ) But it might be, that you want to extend this list a little bit to the emulation of famous gaming virtual machines. ScummVM: http://clb.demon.fi/html5scummvm/ Z-Machine: http://z-machine.lilawelt.de/