Show HN: LuaGB – A Gameboy emulator written in pure Lua | Hacker News Reader

Show HN: LuaGB – A Gameboy emulator written in pure Lua

github.com

136 pointszeta013418 comments

One day when I was really bored in modded Minecraft, I thought it would be a neat idea to see how far I could get writing a Gameboy emulator in ComputerCraft. That idea fell apart shortly after I had a somewhat working z80 chip and realized that the graphics display wasn't possible, but I kept working on the emulator over the course of a year, and this is the result.

It's not the fastest thing in the world, but my own machine manages to play many games full speed, and it supports almost the full feature set of the platform. I'm sure there are bugs, but I'm pretty happy with it overall. Critique and especially bug reports are quite welcome! My own growing Gameboy library is still quite small and I won't test games I don't own for legal reasons.

Off topic: are gameboy games getting expensive where you are?

I usually pick them up on Amazon. I'm going for popular "good" games at the moment, and these tend to run anywhere from $5 - $30 depending on the condition. Most bargain bin games (movie tie-ins, less popular carts) can be had for less than $5, and then there's Shantae, which I can't find for less than $400 because the thing is so darn rare.

how "pure" is this. Can this be integrated somehow as a world of warcraft extension, interface modules there are written in lua as well.

I seems to depend on the Löve Framework for actually drawing the emulation

This release does, yes. The actual emulation of the system is straight Lua and does not require Löve at all. You could run the emulator completely headless (as I was pestering zeta to do during development for testing), but there's not yet a headless driver. This also means that you just have to provide the hooks for drawing/sound/input/file IO to give it a different front end. Löve is what was used because it's what we're familiar with.

The first bullet point under the Supported Features section in the readme states that it works on any Lua that provides a bit manipulation library. I know LuaJIT comes with one, and Lua 5.3 comes with bitwise operators, so those could be wrapped up into a compatible module.

I don't see why not! The release itself uses Love2D just because that's easy to run on most machines, but the gameboy module (in the /gameboy folder) has no non-Lua dependencies or code. Its "bit" library or equivalent should be available in most environments.

Essentially you could use import the /gameboy module, write your own shell as a WoW extension, toss the graphics onscreen somewhere, and optionally deal with audio by setting the appropriate callback.

In the Readme you mentioned that you rip the games yourself - what hardware do you use for that?

It's mentioned in the build section in the Readme - the Joey Generation 3.

I can also recommend the GBCart shield - https://www.tindie.com/products/insidegadgets/gameboy-cart-s.... I've got the newer reader listed on the site but haven't had a chance to test it yet.

If you need a hand dumping games, let me know.

It is nice to see how far this has come. I watched most of the early development on Twitch.

I didn't know you could watch development on Twitch, only gaming and the like.

Do you have any Twitch accounts you'd recommend for this? Thanks....

Handmade Hero - a complete game, from scratch, in C [0] Jon Blow - new programming language (Jai) and game implementation therein [1]

[0] https://www.twitch.tv/handmade_hero [1] https://www.twitch.tv/naysayer88

I've been following the development of this for quite a while, and one feature that is not erm, featured, is that the actual emulator itself is composed of isolated modules. This means that it's possible to swap out say, the graphics implementation to do a high definition drawer, or substitute the processor with a plain Lua script - essentially, it turns the Gameboy itself into a library! This could be used to make higher-level ROM hacks and patches without needing to know the nitty-gritty of the whole system.

This is really neat to see in Lua. The first(?) issue on the project highlights this nicely: https://github.com/zeta0134/LuaGB/issues/1

I constantly underestimate the reach a project like this can have; in this case, the possibility to reuse this base for other easily-portable emulators.

I've been following this project since it began, good luck once you start tackling speed!

what will be your strategy for maintaining this library?

Speaking of, what's the status of LuaJIT?

Reply on news.ycombinator.com