How to Make a Custom Software Application on the Nintendo 2DS

The Nintendo 2DS is a capable little handheld that millions of people still use today — but its appeal goes beyond just playing retail games. A growing community of developers and hobbyists has figured out how to run custom software, homebrew applications, and even original programs on the device. If you're curious how this works, here's a clear breakdown of what's involved, what tools matter, and why your specific situation shapes the entire process.

What "Custom Software" Actually Means on the 2DS

When people talk about running custom software on a Nintendo 2DS, they're usually referring to one of two things:

• Homebrew applications — independently developed programs, games, tools, and emulators that run outside Nintendo's official ecosystem
• Custom firmware (CFW) — a modified version of the 2DS system software that unlocks deeper access to the hardware, enabling homebrew and other functionality

The 2DS runs on the same hardware and firmware platform as the Nintendo 3DS family, which means the same development tools, exploits, and homebrew libraries apply across all of them. This is actually good news — the 3DS/2DS homebrew community is large, well-documented, and has been active for over a decade.

The Foundation: Custom Firmware

To reliably run custom applications on a 2DS, most developers start by installing Luma3DS, which is the most widely used custom firmware for the 3DS platform. Luma3DS patches the system software at boot to allow unsigned code — meaning software that Nintendo hasn't officially approved — to run on the hardware.

The standard installation process involves using an exploit to gain initial access, then using tools like GodMode9 (a full-access file manager for the system) to complete the setup. The primary guide most of the community references is maintained at 3ds.hacks.guide, which covers the process step by step for every hardware revision.

Key terms you'll encounter:

How You Actually Build a Custom Application 🛠️

Once the 2DS has custom firmware installed, you have a platform to deploy software. Actually building that software is a separate skill set entirely.

The primary development toolkit is devkitPro, a collection of compilers and libraries designed for Nintendo handheld development. Within devkitPro, the relevant component is devkitARM — the ARM-based compiler toolchain — paired with libctru, a C library that gives your code access to 2DS/3DS hardware features like the touchscreen, cameras, buttons, and audio.

The general development workflow looks like this:

1. Install devkitPro on your development machine (Windows, macOS, or Linux)
2. Write your application in C or C++ using libctru for hardware access
3. Compile the project into a .3dsx file (for Homebrew Launcher) or a .cia file (for installing directly to the home menu)
4. Transfer the file to the 2DS via SD card
5. Run it through the Homebrew Launcher or installed as a title

There are also community-developed frameworks for higher-level development. Lua Player Plus lets you write applications in Lua, which has a lower barrier to entry than C. Some developers have also used Python ports for scripting-level projects, though these are more limited in what they can access.

Variables That Determine Your Experience

This is where individual situations diverge significantly. The process isn't one-size-fits-all, and several factors shape how straightforward or complex your path will be.

Firmware version on your device Older firmware versions on unmodified 2DS units may require specific exploits that no longer work on newer versions. Some exploits require particular system versions, which affects your entry point into the CFW process.

Your programming background Building something from scratch using devkitARM and libctru requires solid C/C++ knowledge. If you're newer to programming, Lua-based frameworks dramatically lower the entry barrier — but also limit what you can build. The complexity of your application concept needs to match your current skill level, or the learning curve becomes steep quickly.

What you're actually trying to build A simple utility app, a game, an emulator frontend, a media player — these all involve very different complexity levels and library requirements. Some categories of software have existing open-source examples you can learn from; others you'd be starting with minimal reference points.

Development machine and toolchain setup devkitPro behaves differently across operating systems. Linux users often report the smoothest experience. Windows users typically work through MSYS2. macOS setups are functional but occasionally require additional configuration steps.

SD card and file management The 2DS uses a microSD card for storage. Application files, save data, and CFW components all live there. Keeping this organized — and understanding the directory structure — matters more than it might seem early on.

The Spectrum of What Developers Build 🎮

The 2DS homebrew scene covers a wide range of projects:

• Emulators for older platforms (Game Boy, NES, SNES, and others)
• Media players and file managers
• Original games built from scratch using the homebrew toolkit
• Utility tools for managing save files, themes, and system settings
• Ports of open-source games from other platforms

Some of these are maintained by solo developers; others are community efforts with years of active development behind them. The GBAtemp forums and relevant GitHub repositories are where most of this activity lives.

What you build, and how polished it becomes, depends almost entirely on the time you invest, your existing skills, and how well your project concept maps onto what the 2DS hardware can realistically handle.

The Missing Piece Is Your Setup

The technical foundation — CFW, devkitPro, libctru, the file formats — is well-documented and largely stable. But whether you're starting from a stock 2DS with an unknown firmware version, whether you're comfortable in C or need a friendlier language, and what kind of application you actually have in mind — those details determine which path makes sense for you, how long setup realistically takes, and where the friction points will be.