To start coding your own Game Boy games, the first step is setting up a comfortable IDE. In this post, I’ve put together a list of the most convenient and free tools to help you streamline your Game Boy development process and get your projects running as smoothly as possible.

The Tools

When it comes to Game Boy development, there are several tools out there that you can mix and match depending on your workflow and preferences. However, after trying a variety of options, I’ve found that these three — VS Code, GBDK, and Emulicious — offer the most convenient, beginner-friendly, and efficient setup. Together, they form a smooth development pipeline that takes you all the way from writing code to testing and debugging your Game Boy games with ease.

The code editor

When it comes to writing Game Boy games, Visual Studio Code (VS Code) is one of the best choices out there. It’s lightweight, highly customizable, and packed with useful extensions that make coding in C for GBDK much more comfortable. You can add syntax highlighting, project explorers, and even Git integration to keep your development workflow clean and organized. With a few tweaks, VS Code can feel just like a native retro game IDE tailored perfectly for your Game Boy development projects.

The C++ Compiler

The Game Boy Development Kit (GBDK) is the heart of your Game Boy coding setup. It’s a cross-compiler based on the Small C compiler, designed specifically for developing games and software for classic Nintendo Game Boy systems. GBDK takes your C code and converts it into Game Boy ROM files that can be played on emulators or even real hardware. It includes essential libraries for graphics, sound, and input handling, so you can focus on gameplay and creativity instead of worrying about low-level hardware instructions.

Emulator and Debugger

Once your code is compiled, you’ll need a reliable way to test it — that’s where Emulicious comes in. This powerful Game Boy emulator not only runs your ROMs smoothly but also includes excellent debugging tools. You can inspect memory, set breakpoints, watch variables, and step through your code in real time. These features make Emulicious invaluable for finding and fixing bugs quickly. It’s an essential tool for anyone serious about building polished, professional-quality Game Boy games.

The Techniques

Now that we’ve covered the essential tools, it’s time to put everything together. In this section, we’ll go through how to install VS Code, GBDK, and Emulicious, and more importantly, how to link them into a single, seamless workflow. By the end of this setup, you’ll be able to write your Game Boy code, compile it into a ROM, and run or debug it instantly—all from within your development environment. This is where your Game Boy development setup truly comes to life.

Installations

VS Code, GBDK, and Emulicious are cross-platform tools. That means they work across multiple different operating systems. They are easy to install and the installation process for each operating system is very similar. This blog, however, will show you how to install them on a Windows machine.

Installing VS Code

Installing Visual Studio Code (VS Code) on a Windows machine is quick and straightforward. Simply head over to the official VS Code website, download the Windows installer, and run it. During the installation, you can choose to add VS Code to your system PATH—this option is highly recommended, as it allows you to open files or folders directly from the command line. Once the installation is complete, launch VS Code, and you’ll be greeted with a clean, minimal interface ready for customization. You can then install useful extensions like C/C++ to enhance your Game Boy development experience.

Installing GBDK

Installing GBDK (Game Boy Development Kit) on a Windows machine is also a simple process. Start by visiting the official GBDK GitHub page and downloading the latest release for Windows. Once downloaded, extract the contents of the ZIP file to a convenient location on your computer, such as C:\gbdk. Next, you’ll need to add the GBDK bin folder to your system’s PATH environment variable—this allows you to run the compiler from any directory in the command prompt. To verify the installation, open a new terminal and type lcc --version; if everything is set up correctly, you’ll see the GBDK version information displayed. With that, your Game Boy compiler is ready to go.

Installing Emulicious

Installing Emulicious is simple and straightforward. Since it’s a Java-based emulator, you’ll first need to have Java Runtime Environment (JRE) version 8 or higher installed on your computer. Once Java is ready, visit the official Emulicious website and download the latest version for your operating system (Windows, macOS, or Linux). The download comes as a compressed ZIP file—just extract it to a convenient location on your computer, such as your development or emulator folder. There’s no installation process required; simply double-click the Emulicious.jar file to launch the emulator. You can then load your Game Boy ROMs directly or integrate Emulicious with Visual Studio Code for instant testing during development.

Linking the tools

With all three tools installed, the next step is to make them work together seamlessly. In this section, we’ll connect VS Code, GBDK, and Emulicious so you can build and test your Game Boy projects with a single key press. By configuring VS Code to recognize GBDK’s header files and compiler, and by setting up a custom build task, you’ll be able to compile your code and automatically launch the resulting ROM in Emulicious for instant testing. This integration not only saves time but also creates a smooth, modern workflow that makes Game Boy development feel effortless and efficient.

First, let’s set a well-defined goal

Before we move on, let’s set a clear goal to see how these tools work together in action. For this example, we’ll create a simple program that prints “Hello World!” on the Game Boy screen (or in Emulicious). I’ll walk you through each step to make it all come together.

For this goal, the code is very simple:

#include <gb/gb.h>
#include <stdio.h>

void main() {
    printf("Hello World!");
}

To write the code in VS Code, start by opening the program and going to File → Open Folder. Navigate to (or create) the directory where you’d like to store your project files—for example, a folder named “game_project.”

After pressing Enter, there will be a pop-up windows asking if you trust the authors of the files in this folder? Just click yes.

Once the folder is open, look at the Explorer panel on the left-hand side. Right-click inside it and select “New File,” then name the file main.c.

If this is your first time using Visual Studio Code, it’s a good idea to install the C/C++ IntelliSense extension. This tool enhances your coding experience with smart features like auto-completion, real-time error checking, and quick navigation. It helps you jump to function definitions, view details instantly, and manage include paths seamlessly—turning VS Code into a lightweight yet powerful IDE for writing, debugging, and organizing C or C++ projects efficiently.

To install it, click the Extensions icon on the left sidebar (or press Ctrl + Shift + X), search for “C/C++”, then select C/C++ IntelliSense from Microsoft and click Install.

Finally, in the code editor pane on the right, paste the example code you wrote earlier. Your project is now ready for compiling.

Setting up paths for header and compiler files

From the code, you’ll notice an error right away. Now that the IntelliSense extension is installed, Visual Studio Code recognizes that you’re writing a C program—but it can’t find the gb.h header file, which contains the functions used to communicate with the Game Boy hardware. To fix this, we need to customize the include path settings so VS Code knows where the compiler and its libraries are located. If you click on the first line with the red squiggly underline, you’ll see a small light bulb icon appear to the left of the line number. Click on that icon, then select “Edit include path setting” to configure the correct directory.

At this point, you’ll see a new tab appear on the right — you can safely ignore it. Instead, go to the Explorer panel and open the .vscode folder. Inside, click on the file named c_cpp_properties.json. This is where you’ll edit the include path to link Visual Studio Code with the C compiler from GBDK, allowing IntelliSense to recognize the Game Boy libraries properly.

Copy and paste the following code in the c_cpp_properties.json file:

{
    "configurations": [
        {
            "name": "Win32",
            "includePath": [
                "${workspaceFolder}\\**",
                "${workspaceFolder}\\..\\resources\\gbdk\\include\\**",
                "${workspaceFolder}\\..\\resources\\gbdk\\include\\gbdk\\**"
            ],
            "defines": [],
            "compilerPath": "${workspaceFolder}\\..\\resources\\gbdk\\bin\\sdcc.exe",
            "cStandard": "c17",
            "cppStandard": "gnu++17",
            "intelliSenseMode": "windows-gcc-x64"
        }
    ],
    "version": 4
}

The code above tells VS Code where to find the gb.h header file. This path will vary depending on your operating system. For example, on macOS, the “name” field would change to “Mac”, and the backslashes (\\) would become forward slashes (/). The “includePath” also depends on where you placed your downloaded GBDK folder. In my case, I stored it one level above my working directory (represented by ${workspaceFolder}) inside another folder named “resources”. That’s why the path begins with “..“ — to move up one directory before entering “resources”, then “gbdk”, and so on. In this context, the double asterisks (**) mean “include everything” within that folder.

In addition, you’ll notice that we also tell VS Code where to find the compiler (sdcc.exe) in the setting after “compilerPath“.

Setting up a custom build task

After setting up the paths for the header and compiler files, the next step is to tell VS Code how to build the program using the lcc command. The basic command looks like this:

lcc -o image.gb source.c

Here, image.gb is the output Game Boy ROM, and source.c is your source file. You can adjust this command to fit your project structure. For example, I want my output file to be named game.gb, my source file is main.c, and I’d like all build-related files stored in a folder called build. My customized command looks like this:

if (!(Test-Path build)) { mkdir build } ; ..\\resources\\gbdk\\bin\\lcc -debug -o build\\game.gb main.c 

This is a Windows PowerShell command that means:
“If there’s no folder named build, create one. Then compile the program with lcc and place all output files in that folder. If the build folder already exists, overwrite its contents with the new build.”

Now, we just have to create a tasks.json file in .vscode folder by right-clicking at the folder name in the project explorer panel on the left and choose “New File…” and copy and paste the following code in that file:

{
    "version": "2.0.0",
    "tasks": [
        {
          "label": "Build ROM",
          "type": "shell",
          "command": "if (!(Test-Path build)) { mkdir build } ; ..\\resources\\gbdk\\bin\\lcc -debug -o build\\game.gb main.c ",
          "problemMatcher": ["$gcc"],
          "group": {
            "kind": "build",
            "isDefault": true
          }
        }
    ]
}

Notice that we put the lcc command that we discussed earlier in the “command” filed.

Linking Emulicious to VS Code

At this stage, if you build the project by pressing Ctrl + Shift + B, VS Code will generate your game.gb file—along with all other debugging-related files—and place them neatly inside the build folder. You can then manually open Emulicious by navigating to its folder and double-clicking emulicious.exe (or, on macOS and Linux, launching emulicious.jar with Java). Once Emulicious is running, load the game.gb file to test your build. However, this multi-step process can be streamlined even further by linking Emulicious directly to VS Code, allowing you to simply press F5 to compile and automatically launch your game in Emulicious—making your development workflow fast, efficient, and effortless.

First, we need to connect Emulicious with VS Code by installing the Emulicious Debugger extension. The process is the same as installing the C/C++ extension: click the Extensions icon on the left sidebar, type “Emulicious” in the search bar, and then click Install.

Next, we need to manually launch Emulicious one more time. Once it’s open, navigate to Tools → Remote Debugging → Enabled and ensure there’s a ✓ checkmark next to Enabled.

Now, switch back to VS Code and press Ctrl + Shift + P to open the Command Palette. Type “Emulicious” in the search bar, then select “Emulicious: Attach to Emulicious” from the list.

Once VS Code and Emulicious are properly linked, the next step is to tell VS Code to use Emulicious as the default debugging tool. To do this, click the Run and Debug icon on the left sidebar, then open the drop-down menu at the top and select “Add Configuration…”.

At this point, a launch.json file will be automatically created, and its tab will open in the editor. Add the following code inside that file—it instructs VS Code to automatically launch your Game Boy program in Emulicious whenever you press F5.

{
    "version": "0.2.0",
    "configurations": [
        
        {
            "type": "emulicious-debugger",
            "request": "launch",
            "name": "Launch in Emulicious",
            "program": "${workspaceFolder}\\build\\game.gb",
            "emuliciousPath": "D://Game Boy//resources//Emulicious//Emulicious.exe",
            "port": 58870,
            "stopOnEntry": false,
            "preLaunchTask": "${defaultBuildTask}"
        }
    ]
}

Finally!

Once everything is set up, launching and debugging your Game Boy project becomes incredibly easy. Simply press F5 in VS Code, and it will automatically build your project using GBDK, then launch Emulicious with your freshly compiled ROM loaded and ready to run. You can now play, test, and debug your game directly from Emulicious’s powerful debugger tools—such as memory inspection, breakpoints, and step-by-step execution—all seamlessly connected to your VS Code environment. This setup transforms the classic Game Boy development process into a smooth, one-button experience.

The result: Emulicious now launches automatically every time you press F5, displaying the output of your code—in this case, “Hello World!”. This setup makes debugging incredibly convenient, as any changes you make to the code are immediately reflected the next time you run the debugger. With this workflow, you can test, view results, and debug on the fly—all within a single, seamless environment.

And that’s it—you’ve just completed your full Game Boy IDE setup! With VS Code, GBDK, and Emulicious all working together, you now have a modern, streamlined workflow that brings retro game creation into the present day. From writing and compiling code to instantly testing and debugging, everything is just a few keystrokes away. Whether you’re building your first “Hello World!” or crafting a full-fledged Game Boy adventure, this setup gives you the perfect foundation to turn your ideas into playable reality. Thank you & see you around.