# ACGC-PC-Port runs the decompiled GameCube Animal Crossing on x86 through an OpenGL translation layer

> ACGC-PC-Port is an unofficial native PC port of Animal Crossing for GameCube, built on the ACreTeam decompilation and replacing the GX graphics API with OpenGL 3.3. It fits a player who wants the GameCube game running natively on Windows with modern graphics options, and it does not fit anyone who wants a version-agnostic or multi-platform release, since only the USA Rev 0 disc is supported.

**flyngmt/ACGC-PC-Port** — Unofficial PC Port of Animal Crossing Gamecube

- Repository: https://github.com/flyngmt/ACGC-PC-Port
- Stars: 1,515 · Forks: 132
- Language: C
- License: NOASSERTION
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/flyngmt-acgc-pc-port

## The port runs the original C code, it does not reimplement the game

ACGC-PC-Port is a native PC port of Animal Crossing for GameCube, and the mechanism is stated in one sentence: the game's original C code runs natively on x86, with a custom translation layer replacing the GameCube's GX graphics API with OpenGL 3.3.

That is a decompilation-based port rather than a rewrite, and the difference matters for what you can expect. The foundation is the complete C decompilation of Animal Crossing by the ACreTeam decompilation team, and the README credits that team directly, saying the project would not be possible without their work. The decompilation is the source of truth for the game's behaviour, and the port's job is to make that code compile and run on a PC with a graphics API the PC has.

The repository layout shows the split. The src/ and include/ directories hold the game code and headers, orig/ holds the original code the decompilation was based on, pc/ holds the PC-specific porting layer, config/ holds configuration, assets/ holds assets for the port itself, tools/ and docs/ hold supporting material, and configure.py plus build_pc.sh drive the build. The .clang-format file and the presence of a .flake8 suggest mixed C and Python tooling.

The releases are named with a playtest suffix, v0.9.3-playtest, v0.9.2-playtest and v0.9.1.1-playtest, and the last push was on 2026-08-02. The naming tells you how the project positions itself: a work in progress that is playable, not a finished port.

## No assets in the repository, and the disc image is the content source

The README is explicit about this: the repository does not contain any game assets or assembly whatsoever, and an existing copy of the game is required. The supported version is listed as GAFE01_00: Rev 0 (USA).

That single supported revision is the hard boundary of the project. A European or Japanese disc, or a later revision, is not covered, and there is no mechanism described for adapting to them. The port is built against one specific binary's data layout, and the assets are read from the disc image at runtime rather than baked in.

The runtime behaviour is convenient. The game reads all assets directly from the disc image at startup, and no extraction or preprocessing step is needed. You put the image in the rom/ folder and the game finds what it needs. The accepted formats are ISO, GCM and CISO.

This is the standard arrangement for a decompilation-based port, and it is what keeps the repository legally clean of Nintendo's assets while still letting the game run unmodified in content terms. The cost is that the port is useless without a disc you own, and it is tied to the revision the decompilation targeted.

## The quick start is a download, a rom folder and an executable

Pre-built releases are published on the repository's Releases page, and the README says no build tools are required. The procedure is three steps: download and extract the latest release zip, place your disc image in the rom/ folder, and run AnimalCrossing.exe.

That is the whole setup for the intended user, and it is worth noting that the binary is a Windows executable, which means the port is a Windows port in practice even though the README describes it as a native PC port and the build system is an MSYS2 MinGW32 cross-style toolchain targeting 32-bit Windows.

The build from source is for people who want to modify the code, and the README says so directly. The requirements are MSYS2 and an Animal Crossing (USA) disc image in ISO, GCM or CISO format. You open MSYS2 MINGW32 from the Start menu and install the toolchain packages:

```bash
pacman -S mingw-w64-i686-gcc mingw-w64-i686-cmake mingw-w64-i686-SDL2 mingw-w64-i686-make
```

The i686 packages are the 32-bit variant, which matches the build output paths later in the instructions. Then you clone the repository, run the build script from the MSYS2 MINGW32 shell, place the disc image at pc/build32/bin/rom/YourGame.ciso, and run pc/build32/bin/AnimalCrossing.exe.

The build commands themselves are short. Cloning is git clone https://github.com/flyngmt/ACGC-PC-Port.git followed by cd ACGC-PC-Port, and the build is ./build_pc.sh.

## Graphics options are the point of the port

The settings.ini file holds the graphics configuration, editable by hand or through the in-game options menu. The options listed are resolution up to 4K, a fullscreen toggle, VSync, MSAA anti-aliasing, and texture loading and caching, with a note that texture loading and caching need not be enabled if you are not using a texture pack.

These are exactly the settings a GameCube emulation configuration would expose, and that is the value proposition. The GameCube's GX API offered a fixed set of video modes and no anti-aliasing, so getting MSAA and 4K on the original hardware was not a matter of configuration. A native port backed by OpenGL 3.3 delivers them natively.

The command line options are small and diagnostic rather than configuration-heavy. --verbose enables diagnostic logging, --no-framelimit disables the frame limiter for unlocked FPS, --model-viewer [index] launches a debug model viewer for structures, NPCs and fish, and --time HOUR overrides the in-game hour from 0 to 23.

The model viewer is a development tool that doubles as a research tool. Being able to inspect the game's structures, NPCs and fish outside the normal game flow is the kind of thing that makes a decompilation project interesting to work on, and its presence in a shipped build suggests the port is not a black box.

Texture packs go in a texture_pack/ directory in a Dolphin-compatible format, XXHash64 and DDS. The README links to an HD texture pack built by members of the Animal Crossing community on the Dolphin forums and recommends it.

## Input is remappable and gamepads work through SDL2

Keyboard bindings are customised through a keybindings.ini file next to the executable, and mouse buttons can be assigned as Mouse1, Mouse2 and Mouse3.

The default keyboard mapping maps the GameCube controller onto a keyboard in a way that is easy to remember. WASD moves, corresponding to the left stick, and the arrow keys handle the camera, the C-stick. Space is the A button, Left Shift is the B button, Enter is Start, X is the X button, and Y is the Y button. Q and E are the L and R triggers, Z is the Z trigger, and I, J, K and L form the D-pad for up, left, down and right.

That layout is a design decision rather than a default, since it puts the D-pad on the right hand side of the keyboard near the movement keys. It works, but it is not what a Nintendo controller layout would suggest, and the ini file exists for anyone who disagrees.

Gamepads are handled through SDL2 with automatic hotplug detection, and the button mapping follows the standard GameCube layout. That last point removes the main reason a keyboard-only port would be awkward for a GameCube game, since this title is played with the C-stick and D-pad constantly and both are awkward on a keyboard.

Save data is stored in a save/ directory in the standard GCI format, which is compatible with Dolphin emulator saves, and a Dolphin GCI export placed in that directory imports an existing save. That interoperability is what makes the port a viable option for someone moving from the emulator, rather than starting from nothing.

## What this port is not, and the licence question behind it

The limitation that matters most is platform and revision. There is one supported game version, GAFE01_00 Rev 0 USA, and the build instructions are for Windows with an i686 MinGW toolchain producing a.exe. The README does not describe a Linux or macOS build, and the pre-built release is a Windows zip.

For a Linux user you would need to work out the build yourself. For a PAL or Japanese disc owner, the port does not apply as written.

The licensing situation is the other thing to check. The repository licence is a custom one that GitHub cannot classify, and the README states the port is unofficial. A decompilation-based port of a copyrighted game sits in legally sensitive territory, and a custom licence rather than an OSI-approved one is a deliberate choice by the author. Anyone considering distribution or commercial use needs to read the LICENSE file rather than assume any standard terms, and no legal conclusion should be drawn from this article.

The project also discloses its use of AI tooling, stating that AI tools such as Claude were used in this project, with the parenthetical that this applies to the PC port code only, which is a distinction from the decompiled game code the port is based on.

Against that, the honest positives are real. You get the GameCube game running natively on Windows, with modern display options, controller support, and Dolphin-compatible saves. The FAQ.md file holds more detail, and the docs/ directory suggests the port is documented beyond the README.

## Conclusion

ACGC-PC-Port fits a Windows player who owns a USA Rev 0 Animal Crossing disc and wants the game running natively with OpenGL 3.3, higher resolutions, MSAA and texture packs, and it does not fit a Linux or macOS user, a PAL or Japanese disc owner, or anyone needing a clean licensing story. Before building, check the supported version, which is GAFE01_00 Rev 0 USA only, and note that the repository ships no assets, so a disc image in ISO, GCM or CISO format is required and the game reads it directly at startup.

## FAQ

### What game versions does ACGC-PC-Port support?

The README lists a single supported version, GAFE01_00: Rev 0 (USA), and requires an Animal Crossing (USA) disc image in ISO, GCM or CISO format. The game reads all assets directly from the disc image at startup, with no extraction or preprocessing step.

### How do I install ACGC-PC-Port?

Download and extract the latest release zip from the repository Releases page, place your disc image in the rom/ folder, and run AnimalCrossing.exe. No build tools are required for the pre-built release.

### How do I build ACGC-PC-Port from source?

You need MSYS2 and an MINGW32 shell, and you install the toolchain with pacman -S mingw-w64-i686-gcc mingw-w64-i686-cmake mingw-w64-i686-SDL2 mingw-w64-i686-make. Then clone the repository, run ./build_pc.sh from the MSYS2 MINGW32 shell, and run pc/build32/bin/AnimalCrossing.exe.

### Can I use my Dolphin emulator save in ACGC-PC-Port?

Yes. Save files are stored in the save/ directory in the standard GCI format, which is compatible with Dolphin emulator saves, and you can import an existing save by placing a Dolphin GCI export in that directory.

## Sources

- [flyngmt/ACGC-PC-Port on GitHub](https://github.com/flyngmt/ACGC-PC-Port)
- [Issues](https://github.com/flyngmt/ACGC-PC-Port/issues)
- [README](https://github.com/flyngmt/ACGC-PC-Port/blob/master/README.md)
- [Releases](https://github.com/flyngmt/ACGC-PC-Port/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/flyngmt-acgc-pc-port