Setting up a Homebrew Development Environment for Nintendo Platforms on Windows

Coding for Video Game Consoles

Through the wonderful world of homebrew, you can develop your own games, applications and run custom code on your favorite consoles or emulators. The Nintendo homebrew scene blew up in the early 2000s with the Game Boy Advance (GBA) and Nintendo DS as people found ways to execute custom software on these devices using independently built and open-source development tools. This meant you didn’t have to be part of an established game studio to make games, anyone who knew how to code, or wanted to learn how to code could do it themselves.

Today, these tools have continued to mature and expand to modern consoles like the Nintendo Switch. Nintendo has made it slightly easier to get your hands on their official development kit but if you go that route you’ll still have to go through an application process, convince them that you’ve got something good, and sign an NDA which will prohibit you from openly discussing their development tools. This is well within their right, and a necessary process if you are planning on selling your creation as an officially licensed Nintendo product. But what if you just want to start building games or software without a particular title in mind, or you want to build for older systems that are no longer in production?

Fortunately you can with freely available homebrew tools. Homebrew can be a great way to learn game development and familiarize yourself with console hardware. In this tutorial, we’ll be setting up a homebrew development environment on Windows. MacOS users can do the same here, and Linux users can here. Once you’re set up, you’ll be able to start building games and writing code for any of the following consoles:

  • Game Boy Advance (GBA)
  • Nintendo DS
  • 3DS
  • Gamecube (GC)
  • Wii
  • Wii U
  • Nintendo Switch
      (See below for older Nintendo Consoles)

By the end of this tutorial, you’ll be able to build a ROM file that you can test right away on an emulator.

Although not covered in this tutorial, you can build homebrew for older Nintendo consoles as well:

Installing Homebrew Toolchains

We’ll be using devkitPro, a tried and true producer of homebrew toolchains for Nintendo consoles. Go to the official devkitPro Getting Started guide and follow their instructions under “Windows” to download the latest version of the graphical installer from the GitHub releases page. You'll be downloading an installer called “devkitProUpdater-X.X.X.exe”.

Run through the installation process as they describe in their Getting Started guide under “Windows”. A couple of things to note: During the process you can select which consoles you want to install tools for. By default, all consoles will be included in the installation. We will be running through and building a ROM for the GBA, so be sure to leave that checked during the installation. We will be using MSYS for entering commands when we compile below. For instructions on opening MSYS for your specific version of Windows, again, see devkitPro's Getting Started wiki here.

Building a ROM and Testing it on an Emulator

Free and open-source emulators exist for all Nintendo consoles. In our example, we are building a .gba ROM, so we'll need a GBA emulator. For this, we'll be using Visual Boy Advance (VBA) which is one of the best and most popular GBA emulators that’s been around for decades.

  1. Download and Install an emulator for your target console.

    In our case you can download VBA here and follow these installation instructions for Windows .
  2. Create a new directory for your homebrew project:

    Enter the following in MSYS or right click and create a new folder with the name “hello-gba”:

    $ mkdir hello-gba

    When you installed the console tools from running “devkitProUpdater-X.X.X.exe”, it added example projects for each console including the GBA. These files should be in “C:\devkitPro\examples”, where you’ll see examples for each console you have installed. For me, the GBA examples are in “C:\devkitPro\examples\gba“. You can also get these files here. We'll be building the “template” example which is really just a “Hello World” program.
  3. Write the code for you project. Or in our case, just copy the contents of “C:\devkitPro\examples\gba\template” to the “hello-gba“ directory you created in the previous step. The same files are also available here. Make sure to copy all of the contents. You should have a 'Makefile', 'template.pnproj' file, and a 'source/' folder with 'template.c' inside.
  4. Now cd into your project directory and build the project:

    $ cd hello-gba
    $ make

    After running 'make' you should see output like this:

    Your project directory should now have a 'build/' directory, an .elf file and a .gba ROM—in our case named “hello-gba.gba”. Now let’s test that it works.
  5. Test your ROM in an emulator. Open “hello-gba.gba” with Visual Boy Advance:

    Congrats! You’ve built a GBA ROM. If you want, you could run this on actual hardware with a GBA flashcart. You can pick up the EZ Flash Omega or EverDrive GBA series from Amazon, or shop around Ebay or AliExpress for less expensive options.

    From here you might want to try modifying the 'Hello World' example, building more GBA examples, and compiling programs for other consoles.

Building for Other Consoles

The process is very similar for other consoles:

  1. Install the appropriate tools with “devkitProUpdater-X.X.X.exe” for your target console if they aren’t already installed
  2. Get an emulator for the console
  3. Create a new project or build an example project to create a ROM
  4. Test the ROM on the emulator.
The devkitPro examples are a fantastic resource for getting started with basic functionality. Console specific examples are added when you install tools for each new console, and are also provided by the devkitPro team on their GitHub: See Examples. You may already have all the examples you need if you let the installer/updater install all console tools initially. You can test whatever you build on an emulator, and if everything looks good, you can then test on actual hardware.

That does it for this tutorial. See our Tutorials Section for more tutorials like this one.