Porting Super Mario 64 To The Original Nintendo DS

February 20, 2026 by Maya Posch 8 Comments

Considering that the Nintendo DS already has its own remake of Super Mario 64, one might be tempted to think that porting the original Nintendo 64 version would be a snap. Why you’d want to do this is left as an exercise to the reader, but whether due to nostalgia or out of sheer spite, the question of how easy this would be remains. Correspondingly, [Tobi] figured that he’d give it a shake, with interesting results.

Of note is that someone else already ported SM64 to the DSi, which is a later version of the DS with more processing power, more RAM and other changes. The reason why the 16 MB of RAM of the DSi is required, is because it needs to load the entire game into RAM, rather than do on-demand reads from the cartridge. This is why the N64 made do with just 4 MB of RAM, which is as much RAM as the NDS has. Ergo it can be made to work.

The key here is NitroFS, which allows you to implement a similar kind of segmented loading as the N64 uses. Using this the [Hydr8gon] DSi port could be taken as the basis and crammed into NitroFS, enabling the game to mostly run smoothly on the original DS.

There are still some ongoing issues before the project will be released, mostly related to sound support and general stability. If you have a flash cartridge for the DS this means that soon you too should be able to play the original SM64 on real hardware as though it’s a quaint portable N64.

Continue reading “Porting Super Mario 64 To The Original Nintendo DS” →

The Joy Of Making Handheld Tetris From Scratch

February 19, 2026 by Donald Papp 3 Comments

As anyone who’s made a thing knows, a lot of work goes into bringing something from idea to completion. But there’s also considerable satisfaction in the process. [Willian] recently did exactly that, and shares the joyful experience of creating a homebrew handheld game gadget from scratch. It runs a homebrewed Tetris clone (as well as Snake), and we love the results.

The game gadget uses an ATmega328P programmed via the Arduino IDE, and a 1.8″ TFT color LCD screen. It’s self-contained in a box with a few buttons as controls and runs off three AAA cells. [Willian] made the smart design choice to run the microcontroller at 8 MHz instead of the more common 16 MHz, because doing so meant the board can run at 3.3 V instead of 5 V. Why does this matter? The LCD display runs off 3.3 V as well, and if all components can run off the same supply and logic levels, it simplifies things considerably.

Also, creating a 3.3 V supply is a simple matter of three alkaline cells in series with an LDO (low drop-out) regulator, which is great for a handheld device. We do note that AA cells have a considerably higher energy density and capacity than AAA cells and are usually the better choice, but one works with what one has, and sometimes the space and weight saved by AAA is just too good to pass up.

The software has some notable approaches to keep things responsive and optimal. Instead of defining each of the Tetris pieces as a 2D shape, [Willian] instead pre-defines each piece (and their rotations) so that rotating a piece is just an index change in an array, instead of a transform implementing a rotation. Also, full-screen redraws are comparatively slow over SPI and caused flickering, so only cells that have changed are redrawn to the screen to keep things responsive. The code is all on GitHub, and it’s a great peek at how things get implemented under the hood.

The enclosure is just cardboard, and it does the job in [Willian]’s case. But we’ll point out that cardboard is actually a highly adaptable material from which to prototype. With just a few tips and a little care, paper products can be your new best friend when it comes to one-offs and prototypes.

An Open Source Client For World Of Warcraft

February 18, 2026 by Lewin Day 5 Comments

When World of Warcraft was launched in 2004, it became somewhat of a juggernaut in the MMORPG space. Millions of players continue to login every month. [Kelsi Davis] is one such player, but she doesn’t always log in with the regular client anymore. That’s because she put together WoWee—an open-source alternative of her very own.

WoWee is an acronym—World of Warcraft Engine Experiment. Coded in native C++, it’s a homebrewed client that uses a custom OpenGL renderer to display the game world. [Kelsi] notes that it’s strictly an “educational/research” project, built without using any official Blizzard assets, data or code. Instead, it grabs some client data from a legally-obtained install to operate and loads certain assets this way.

It’s currently compatible with the vanilla game as well as The Burning Crusade and Wrath of the Lich King expansions. It should be highlighted how much work this project has already involved—with [Kelsi] needing to recreate various functional minutae in the game, from character creation screens to weather systems and skyboxes. There’s still a lot to do, as well, like adding 3D audio support and making it more interoperable with the quest system.

It’s rare that any MMO gets an open-source client, even less so while the original game is still being actively supported by the developers. Still, we do see some creative hacks in this space.

Continue reading “An Open Source Client For World Of Warcraft“ →

Software Development On The Nintendo Famicom In Family BASIC

February 15, 2026 by Maya Posch 9 Comments

Back in the 1980s, your options for writing your own code and games were rather more limited than today. This also mostly depended on what home computer you could get your hands on, which was a market that — at least in Japan — Nintendo was very happy to slide into with their ‘Nintendo Family Computer’, or ‘Famicom’ for short. With the available peripherals, including a tape deck and keyboard, you could actually create a fairly decent home computer, as demonstrated by [Throaty Mumbo] in a recent video.

Continue reading “Software Development On The Nintendo Famicom In Family BASIC” →

Inside Raiders Of The Lost Ark (Atari Style)

February 13, 2026 by Al Williams 5 Comments

It’s a bit ironic that an Atari 2600 game based on Raiders of the Lost Ark — a movie about archaeology — is now the subject of its own archaeological expedition as [Dennis Debro] and [Halkun] spent time reverse-engineering the game. Luckily, they shared their findings, so you can enjoy it the same way you can visit a king’s tomb without having to discover it and dig for it. If you don’t remember the game, you might enjoy the demo from [Speedy Walkthroughs] in the video below.

If you are only used to modern software, you might think this is little more than someone dumping the program code and commenting it. However, on these old, limited systems, you have to really understand the actual architecture because there are so many things you have to manage that are specific to the hardware.

For example, the game has two 4K ROM banks that use a strange switching mechanism. The entire game is built around the NTSC television signal. Everything is oriented toward generating the 60 Hz frame rate. Game logic runs during the vertical blanking and over-scan sections to prevent strange visible artifacts due to software running.

This is a fascinating look inside game coding as it existed around 1982. Of course, you can also run everything using emulation. Usually, our reverse engineering is more hardware-related. But we do love these old games, too.

Continue reading “Inside Raiders Of The Lost Ark (Atari Style)” →

Exploring Homebrew For The Pokémon Mini

February 12, 2026 by Maya Posch 3 Comments

Originally only sold at the Pokémon Center New York in late 2001 for (inflation adjusted) $80, the Pokémon Mini would go on to see a release in Japan and Europe, but never had more than ten games produced for it. Rather than Game Boy-like titles, these were distinct mini games that came on similarly diminutive cartridges. These days it’s barely remembered, but it can readily be used for homebrew titles, as [Inkbox] demonstrates in a recent video.

Inside the device is an Epson-manufactured 16-bit S1C88 processor that runs at 4 MHz and handles basically everything, including video output to the monochrome 96×64 pixel display. System RAM is 4 kB of SRAM, which is enough for the basic games that it was designed for.

The little handheld system offered up some capabilities that even the full-sized Game Boy couldn’t match, such as a basic motion sensor in the form of a reed relay. There’s also 2 MB of ROM space directly addressable without banking.

Programming the device is quite straightforward, not only because of the very accessible ISA, but also the readily available documentation and toolchain. This enables development in C, but in the video assembly is used for the added challenge.

Making the screen tiles can be done in an online editor that [Inkbox] also made, and the game tested in an emulator prior to creating a custom cartridge that uses an RP2040-based board to play the game on real hardware. Although a fairly obscure gaming handheld, it seems like a delightful little system to tinker with and make more games for.

Continue reading “Exploring Homebrew For The Pokémon Mini” →

Building A Self-Playing Chess Board Robot

February 10, 2026 by Maya Posch 12 Comments

As popular as the game of chess is, it has one massive flaw. This being that it requires two participants, which can be a challenge. Although playing chess on a computer against an AI has been a thing for many decades, it’s hard to beat physical chess boards that give you all the tactile pleasure of handling and moving pieces, yet merging the two is tricky. You can either tell the player to also move the opponent’s pieces, or use a mechanism to do so yourself, which [Joshua Stanley] recently demonstrated in a video.

There are a few ways that you can go about having the computer move and detect the pieces. Here [Joshua] chose to use Hall magnetic sensors to detect the magnets that are embedded in the 3D printed chess pieces as well as their absence. These sensors are mounted to the back side of a PCB which is also the playing field, thus using the silkscreen for the board markings.

For the electromagnet that moves the chess pieces core x/y kinematics were used to move it underneath the PCB, engaging when moving pieces but otherwise deactivated. This is all controlled by an ESP32 MCU, while the computer runs the open-source Stockfish chess engine. As the human player changes piece positions this is detected by the magnet’s presence, with the change input into Stockfish.

Continue reading “Building A Self-Playing Chess Board Robot” →