Novice Coders Can Create Classic Game Boy Games

It takes a lot of work to build a modern video game. Typically an entire company will spend months (at least) developing the gameplay, selecting or programming an engine, and working out the bugs. This amount of effort isn’t strictly necessary for older video game systems though, and homebrew developers are quite often able to develop entire games singlehandedly for classic systems. In the past it would have taken some special software, programming knowledge, and possibly hardware, but now anyone can build games for the original Game Boy with minimal barriers of entry.

The project is known as GB Studio and allows people to develop homebrew games for the 8-bit handheld system without programming knowledge. Once built, the games can be played on any emulator or even loaded onto a cartridge and played on original hardware if a flash cart is available. Graphics can be created with anything that can create a .png image, and there are also some features that allow the game to be played over a web browser or on a mobile device.

While it seems like the gameplay is limited to RPG-style games, this is still an impressive feat, and highly useful for anyone curious about game development. It could also be an entry into more involved game programming if it makes the code of the games available to the user. It could even lead to things like emulating entire cartridges on the original hardware.

Thanks to [Thomas] for the tip!

Continue reading “Novice Coders Can Create Classic Game Boy Games”

Circuit-Level Game Boy: Upping Emulation Ante By Simulating Every Cycle

Usually when writing emulation software for a system like the Game Boy, one makes sure to take as many shortcuts as possible in order to reduce the resources required for the emulation. This has however the unfortunate side-effect that it reduces the overall accuracy of the emulation and with it the compatibility with games on the system.

This is the basic reasoning behind projects which seek to abandon simplistic abstractions in favor of cycle-accurate, full compatibility approaches, of which MetroBoy is probably the most extreme one. Instead of abstracting away the hardware, it instead does the emulation at the circuit level. As with such other projects, this means that the emulator requires a lot more CPU cycles to get things just right. On the bright side, one can likely still run this emulator on any modern system.

As the MetroBoy author explains, he implemented code in C++ which allowed him to construct circuits in an HDL-style manner, which should theoretically also allow him to generate a Verilog (or VHDL) softcore out of the project. As a demonstration of implementing HDL in C++ it’s decidedly interesting.

An approach like this is pretty much the exact opposite of a project like the UltraHLE (ultra high-level emulator) Nintendo 64 emulator, which used the knowledge that Nintendo 64 games are written in C as a first step to creating libraries that the code in the Nintendo 64 ROMs would call instead of the native (Nintendo) libraries. This allowed N64 games to directly run on the target system, with the graphic and system calls translated by UltraHLE into native OS calls, using the 3dfx Glide API for accelerated graphics.

While an approach like UltraHLE took allows for the most minimal use of system resources by essentially foregoing emulation completely, for retro systems like the Game Boy where games were implemented in assembly on bare hardware, using this circuit-level emulation ensures that one gets the most accurate match with the original handheld console experience.

As a word of caution to those who are now itching to try out MetroBoy, its Github site notes that it currently lacks support for game saves, uses a mixture of original Game Boy (DMG) and Game Boy Advance SP (AGS) hardware that confuses some games and has rather buggy sound support.

If playing around with software-defined Game Boy circuits isn’t enough and would like to literally look inside a real Game Boy, the X-ray image from the top of the article is something Chris over at Elektronaut pulled off several years ago.

The Pocket Emulator That Will Fit In Your Pocket

If there’s one thing tiny Linux Systems on a Chip are good for, it’s emulation. There’s nothing like pulling out an emulation console on the bus for a quick game of old-school NES Tetris, or beating the next level in Super Mario World. This is the smallest emulation console ever. It’ll fit in your pocket, and it has a bright, vibrant screen. It doesn’t get better than this.

This project is an improvement on two projects, both of which are some of the top projects on hackaday.io, the best place on the Internet for hacks and builds. The Keymu is (or was, at the time) the smallest emulation console ever, built as a miniaturized version of the Game Boy Advance SP in a 3D printed case and powered by the Intel Edison. The Edison doesn’t exist anymore, so after that development moved over to the Funkey Zero, a tiny console built around the AllWinner V3s chip and a 240×240 display. Both of these are tiny, tiny consoles, but as silicon gets better there’s always better options, so it’s back to the drawing board.

The design of the Funkey Project is again built on the AllWinner V3S SoC with 64MB of DDR2 DRAM. There’s a 1.5″ display with 240×240 resolution, and of course this retro emulation console retains the classic and very useful clamshell form factor of the famous Game Boy Advance SP.

Already, this project is in the works and it’s shaping up to be one of the most popular projects on hackaday.io ever. Everyone wants an emulation console, and this is the smallest and tiniest one yet. Whether or not this project can carry through to production is another matter entirely, but we’re eager to find out.

Clock Mod Brings Super Game Boy To Competitive Arena

For one time small window between 1994 and 1998, you could play Game Boy games in color with a Super Game Boy. This was a cartridge that plugged into a Super Nintendo, and using proprietary Lock-On™ technology, you could play Game Boy games on the big screen. Inside the Super Game Boy was the guts of a real Game Boy. This was, and still is, the best way to experience everything from Kirby’s Dream Land or the Pokemon of Kanto.

Unfortunately, the Super Game Boy doesn’t exactly replicate the Game Boy experience. The crystal in the Super Game Boy means that games and sound run between 2 and 4% faster. The Super Game Boy is out for competitive speed running, and if you’re using Little Sound DJ, you’ll be out of tune with the rest of the band. The Super Game Boy doesn’t have link cable support, either.

Now, [qwertymodo] over on Tindie has the solution to the faster Super Game Boy. It’s a clock mod, but it’s not just swapping a crystal. This is a board that solders to existing pads, and still allows you to access the speed up and slow down functions available from the Commander controller from Hori. It’s a slightly impressive bit of PCB art, and certainly something that deserves notice.

This mod fixes the 2-4% speedup of the Super Game Boy, but then there’s still one feature missing: the link cable. Well, hold on to your butts, because there’s a mod for this one too. The Super Game Boy Link Port is a small little breakout board that requires fly wires to the main chip in the Super Game Boy. The installation isn’t quite as clean as the crystal hack, but if you’re fixing the clock, you might as well add the link cable port while you’re in there.

[qwertymodo] has a comparison test of the Super Game Boy running Pokemon Red, and this thing is dead on. It runs at exactly the same speed as an original Game Boy, only in color, on a TV. You can check that out below.

Continue reading “Clock Mod Brings Super Game Boy To Competitive Arena”

It’s (Almost) Two Keytars In One!

All the best retro-1980s chiptune acts should possess a keytar. It’s the Law, or something. [Theremin Hero] has reminded us of this with a new video we’ve shown below featuring an instrument he had a part in creating alongside [Sam Wray] and [Siddharth Vadgama] a few years ago. The Blade is a 3D-printed keytar featuring two Guitar Hero necks and an integrated pair of Game Boys to provide the sound from the authentic silicon.

To describe it in those terms though is to miss a wealth of other components and featured. The keyboard itself is from a Rock Band keytar which feeds MIDI to a Raspberry Pi running PD Extended that handles all the button press mappings. An Arduino Mega performs the same task for the two Guitar Hero necks. Midi from the various sources is processed by an Arduino Boy which then feeds the Game Boys that make the sounds. Oh – and there’s a Leap Motion 3D motion controller in the mix as well, though that doesn’t seem to be used directly in the chiptune synth functionality.

We’ve had a few keytars here over the years, but this one makes us think of the Commodore 64 instrument created by [Jeri Ellsworth].

Continue reading “It’s (Almost) Two Keytars In One!”

Game Boy Recreated in Verilog

With the wide availability of Raspberry Pi hardware and pre-baked Linux distros with emulators ready to go, making a retro handheld is easier than ever. Emulation isn’t the only way to go about playing old games however. [Wenting Zhang] decided to instead recreate the Nintendo Game Boy in Verilog, and has documented the effort.

The project runs on a Spartan 6 FPGA. [Wenting] first developed the hardware to use a DualShock controller for input, and output video to a regular LCD monitor. However, work is now underway to produce a handheld VerilogBoy. This will feature a 320×320 LCD screen, with pixels being quadrupled from the original Game Boy 160×144 resolution, with some pixels to spare. [Wenting] is also looking at porting the code to some Pano Logic units, which we’ve discussed before. The thin clients pack FPGA hardware and lots of IO ports that make them perfect for such a project.

Code is available on Github for the curious tinkerers out there. While there are easier ways to play old handheld games, the amount of learning value of such a project should not be underestimated. We’ve seen FPGAs used for other Nintendo hijinx, too – like this NES cart that packs some serious muscle. Video after the break.

Continue reading “Game Boy Recreated in Verilog”

A Game Boy Supercomputer for AI Research

Reinforcement learning has been a hot-button area of research into artificial intelligence. This is a method where software agents make decisions and refine these over time based on analyzing resulting outcomes. [Kamil Rocki] had been exploring this field, but needed some more powerful tools. As it turned out, a cluster of emulated Game Boys running at a billion FPS was just the ticket.

The trick to efficient development of reinforcement learning systems is to be able to run things quickly. If it takes an AI one thousand attempts to clear level 1 of Super Mario Bros., you’d better hope you’re not running that in real time. [Kamil] started by coding a Game Boy emulator in C. By then implementing it in Verilog, [Kamil] was able to create a cluster of emulated Game Boys that enabled games to be run at breakneck speed, greatly speeding the training and development process.

[Kamil] goes into detail about how the work came to revolve around the Game Boy platform. After initial work with the Atari 2600, which is somewhat of a defacto standard in RL circles, [Kamil] began to explore further. It was desired to have an environment with a well-documented CPU,  a simple display to cut down on the preprocessing required, and a wide selection of games.

The goal of the project is to allow [Kamil] to explore the transfer of knowledge from one game to another in RL systems. The aim is to determine whether for an AI, skills at Metroid can help in Prince of Persia, for example. This is arguably true for human players, but it remains to be seen if this can be carried over for RL systems.

It’s rather advanced work, on both a hardware emulation level and in terms of AI research. Similar work has been done, training a computer to play Super Mario through monitoring score and world values. We can’t wait to see where this research leads in years to come.