rosettaboy

As somebody who has written the same gameboy emulator in C++, Rust, and Zig (as well as C, Go, Nim, PHP, and Python) - I have yet to find a place where language affected emulation correctness. Gameboy audio is kind of a pain in the ass (at least compared to CPU, which is fairly easy, and GPU, which is easy to get "good enough” if you don’t care about things like palette colours being swapped mid-scanline) - and some languages take more or less code to do the same thing (eg languages which allow one block of memory to be interpreted in several different ways concurrently will make the “interpret audio RAM as a bunch of registers” code much shorter with less copying) - but in my case at least, each one of my implementations actually has the same audio distortions, presumably because I’m misreading some part of the hardware spec :P https://g

Niceness is subjective, but Nim is just as valid an addition to that group. Nim compiles to C and has had an --os=standalone mode for like 10 years from its git history, and as mentioned else-thread (https://news.ycombinator.com/item?id=36506087) can be used for Linux kernel modules. Multiple people have written "stub OSes" in it (https://github.com/dom96/nimkernel & further along https://github.com/khaledh/axiom). While it can use clang as a backend, Nim does not rely upon LLVM support like Zig or Rust (pre-gcc-rust working). Use on embedded devices is fairly popular: https://forum.nim-lang.org/search?q=embedded (or web search). Latency-wise, for a time, video game programming was a perceived "adoption niche" or maybe "hook" for Nim and games often have stringent frame rendering deadlines. If you are interested in video games, you mi

What's your favorite, and what do you think about Nim? EDIT nvm, found: https://github.com/shish/rosettaboy/tree/master/nim

https://github.com/shish/rosettaboy The same gameboy emulator rewritten in C++, Go, Nim, PHP, Cython, Python, Rust, and Zig (and WIP typescript); mostly to teach myself the languages and to compare and contrast their idioms. Also, when taken with a very large grain of salt, usable as a language benchmark (As with all benchmarks, there are lots of caveats - but as far as I’m aware this is unique in being “the same code in multiple languages” and “several thousand lines of code”): $ ./utils/bench.py rs / lto : Emulated 15763 frames in 10.00s (1576fps) cpp / lto : Emulated 14737 frames in 10.00s (1474fps) rs / release: Emulated 13183 frames in 10.00s (1318fps) cpp / release: Emulated 12966 frames in 10.00s (1297fps) zig / release: Emulated 8792 frames in 10.00s (879fps) nim / speed : Emulated 8127 frames in 10.00s (8

I’ve personally implemented 7 gameboy emulators and I’m half way through my 8th… In my case it’s mostly a fun way to learn a new programming language - an emulator is enough of a “real program” to exercise a load of different aspects of a new language and its standard library to get a feel for how it works, but also small enough that a new implementation can be done in a weekend[0] [0] Assuming you already have the foundational knowledge - my first emulator took a week to get the CPU working and a month for the first game to be playable, only using one old and inaccurate PDF as a reference; now that I know what I’m doing, and now that I’ve found gbdev.io for more accurate docs, it’s much faster. Funnily enough I also ended up creating a tool like the one in this article, logging every action that happens in the CPU or RAM to make sure the

Your comment in PHP src here https://github.com/shish/rosettaboy/blob/master/php/run.sh says # opcache in 8.1 gives a nice speedup (25s to 10s) Is the 23.7 seconds above using the 8.1 opcache?

Checking for my own “benchmark”, a gameboy emulator in several different languages[0]; it’s CPU-bound but across ~3k lines of code, so slightly more representative of real-world apps than a single-function tight-loop microbenchmark: zig: Emulated 600 frames in 0.24s (2521fps) rs: Emulated 600 frames in 0.37s (1626fps) cpp: Emulated 600 frames in 0.40s (1508fps) nim: Emulated 600 frames in 0.44s (1367fps) go: Emulated 600 frames in 1.75s (342fps) php: Emulated 600 frames in 23.74s (25fps) py: Emulated 600 frames in 26.16s (23fps) # PyPy py: Emulated 600 frames in 33.10s (18fps) # 3.11 py: Emulated 600 frames in 61.43s (9fps) # 3.10 Doubling the speed is pretty nice :D Still the slowest out of all implementations though :P [0] https://github.com/shish/rosettaboy EDIT> updated th

Looks very polished, but major disappointment that it's not showcasing OCaml as part of RosettaBoy (https://github.com/shish/rosettaboy)

I’m working on it :) https://github.com/shish/rosettaboy (Ok it’s 5-10k lines rather than a million, but it’s non-trivial enough that the differences between languages are noticable)