Swiss: the file browser that makes GameCube homebrew usable

One program that replaces a pile of one-off loaders

Swiss aims to be an all-in-one homebrew utility for the Nintendo GameCube, and the scope of that word is the whole story.

The reason such a utility exists is that GameCube homebrew comes as DOL and GCM executables that each need to be launched from the right place, and getting them onto the console and started is a separate problem from running them. Swiss solves the first problem: it browses the storage you have, shows what is on it, and loads a DOL or GCM when you pick one.

The device list is where the ambition shows. It browses SDSC, SDHC and SDXC cards through SD Gecko or SD2SP2, DVDs and original game discs through the optical disc drive, Qoob Pro flash memory, USB Gecko remote file storage, WASP or Wiikey Fusion, SMB, FTP and FSP over the Broadband Adapter or ENC28J60, W5500, W6100 or W6300 ethernet chips, a WODE jukebox, IDE-EXI, an M.2 Loader or USB Dolphin, memory cards, GC Loader or CUBEODE, FlippyDrive, KunaiGC flash memory, and FlipperMCE, GCMCE or MemCard PRO GC adapters.

That list is effectively every storage path the console has ever had, and it is what makes the tool a swiss army knife rather than a file manager. The important caveat sits right under it: most devices and the exFAT filesystem are not supported by libogc and only by libogc2. So a good part of that device support depends on which libogc you build against, not on Swiss itself.

It emulates the console's own interfaces, which is how you run commercial software

The second half of the feature list is emulation, and it is a different kind of capability from browsing files.

Swiss can emulate the Processor Interface, the DVD Interface including the optical disc drive, and the External Expansion Interface. Under the expansion interface it emulates a Broadband Adapter through the ENC28J60, W5500, W6100 or W6300 chips, and it emulates memory cards using SD cards. It can also emulate the Audio Streaming Interface.

The purpose of this is straightforward once you understand what these interfaces are for. The GameCube's memory card and optical disc interfaces are what commercial game discs and licensed game saves depend on, so a software loader that emulates them can boot retail discs and read retail saves. That is the point of the DVD Interface and memory card emulation, and it is why the device list includes SD Cards as memory card backing.

There is one restriction that shapes how you build and use the thing, and the documentation states it plainly: emulation is only available for the Dolphin SDK. Homebrew requires native drivers as provided by libogc2.

So there are two build flavours. A Dolphin build gets the emulation, and a native libogc2 build gets you the homebrew side with its own drivers, and that second form is what the services list depends on. The services Swiss provides are the Game ID for BlueRetro, FlipperMCE, MemCard PRO GC and PixelFX RetroGEM GC, profile selection for RetroTINK-4K through ser2net, environment setup and return to loader for libogc2 applications, return to loader for libogc 3.2.0 and newer applications, a legacy mechanism for older ones, and wiiload v0.5 over TCP/IP or USB Gecko.

Building it needs devkitPPC, and the Makefile packs eleven artifacts

Swiss is written in C for the PowerPC target, and the build is driven by a root Makefile that expects the devkitPPC toolchain in the environment.

The two entry points are:

make
make dev

The toolchain variables point at `$(DEVKITPPC)/bin` and `$(DEVKITPRO)/tools/bin/bin2s`, with the compiler, linker, objdump and objcopy all taken from the PowerPC EABI cross toolchain. The `all` target is described as a ready to go 7z file with every type of DOL the project can produce, and it chains together cleaning, patch compilation, the main compile, the packer, a recovery ISO, the AR, GCI, IPL, Wii and USB Gecko server builds, and packaging. The `dev` target is the trimmed version for development, doing only clean, compile-patches and compile.

The project directory layout is `cube/`, `pc/`, `wii/` and `buildtools/`, and the Makefile reaches into them for specific pieces: the Gecko server comes from `pc/usbgecko`, the Wii booter from `wii/booter`, the DOL patcher from `cube/patches` and the packer from `cube/packer`.

Two build details show real portability care. The `dollz3` and `dol2gci` tools are selected as Windows executables when the build runs on Windows and as plain binaries otherwise. And the ISO tool falls back from `mkisofs` to `xorrisofs` depending on what is installed, and the package manager from `dkp-pacman` to `pacman`.

The result is a build that produces more than a single binary: the recovery ISO, the AR and IPL loaders, the GCI build for memory card images, the Wii booter and the USB Gecko server are separate artifacts, and the distribution is a 7z archive rather than a plain executable.

Running it: copy the right DOL to the right device and browse

The usage procedure is short, and the one real trap is device-specific file placement.

You download the latest Swiss release and extract its contents. You copy the Swiss DOL file found in the DOL folder to the device or medium you use to boot homebrew. Then you launch Swiss, browse your device and load a DOL or GCM. The documentation adds a note to check the per-device documentation for where Swiss needs to be placed, because specific devices have specific locations and specific executable file variants.

That note matters more than it sounds. A DOL copied to the wrong path on an SD card simply will not appear in the right place in the browser, and the failure looks like a broken loader rather than a misplaced file.

The requirements are minimal: a GameCube with a controller, and some way to boot homebrew. Nothing in the list requires a network, an ethernet adapter or a particular flash device, which is the point of a tool with this many optional paths.

Once it is running, the interface is a file browser with a device header and a bottom pane. The controls are the GameCube's own: the control stick or the Control Pad navigates, A selects, B enters and exits the bottom pane, X moves back up a folder, Z manages a file or folder, L and R page up and down, and Start or Pause opens the recent list. The top heading shows the version number, the commit hash and the revision number, which is a useful detail when you are comparing against a release build, and the bottom pane holds device selection, the settings groups, system and device information, a return to the top of the file system and a restart of the console.

Where Swiss is the wrong tool

The clearest case is a console you have no way to boot homebrew on. Swiss is a homebrew utility, so it needs an existing way in, and the requirements section lists that as a prerequisite rather than something Swiss provides. If your GameCube is unmodified and you have no modchip, SD adapter or other entry point, Swiss is not the first thing to install, it is something you install afterwards.

The second case is a setup that needs the broad device support. If your storage is an exFAT partition, or a device only libogc2 handles, then the native libogc build will not cover it and you have to build against libogc2, at which point you own the build rather than downloading a binary. The Dolphin build gets you emulation and needs the SDK, so the same split applies there: the downloadable release serves a common configuration, and the unusual ones are yours to build.

The third case is expecting a general-purpose file manager for a modern system. Swiss is a launcher and a device abstraction layer for 2001 hardware. Its interface is a controller-driven browser, and its scope ends at the console's own interfaces.

There is a versioning detail to keep in mind when comparing releases. The tags are named with a revision, v0.6r2119, v0.6r2092, v0.6r2073, and the Makefile derives that number from the commit count with `git rev-list HEAD | wc -l`, so the revision is a build identifier rather than a semantic version. The project is GPL-2.0 licensed with the LICENSE file at the root, the last push was on 2026-10-16, and the repository is not archived.

Editorial conclusion

Swiss fits a GameCube owner who has one storage method and wants a file browser that can boot homebrew and run the console's own software, and it does not fit someone who needs every storage device, exFAT support and peripheral emulation at once, because most of that depends on libogc2 rather than on Swiss itself. Before you flash anything, check which device you are booting from and put the matching DOL variant in the right place, since the documentation states that specific devices need specific locations and executable variants.

Frequently asked questions

Official sources

1. emukidid/swiss-gc on GitHub
2. Issues
3. License: GPL-2.0
4. README
5. Releases