Open Nectar

Open Nectar — Pikmin and Pikmin 2 Native PC/Android Ports

Native, open-source ports of Pikmin (GameCube, 2001) and Pikmin 2 (GameCube, 2004) for Linux, Windows and Android, and macOS from source. They run the games' code directly on the host system and translate GX to OpenGL; no Dolphin or any other emulator is involved. One launcher and one Android APK carry both games.

This project builds upon the decompilations by projectPiki/pikmin and projectPiki/pikmin2 and adds a native port layer.

AI disclosure

This project was developed with the assistance of AI tools. The generated code was reviewed, tested and integrated by me. I mention it because I'd rather be upfront about how this was built.

To make it clear: I'm a coder and I use claude as a tool not as a substitute. I know what is done in my project and how it is done, main problem with open nectar is that I don't have testers, I test myself on my devices where it works fine and once released I fix all the issues reported. Please consider to try the latest release

Project Status

Pikmin 2

Playable from start to finish, natively, on Linux, Windows and Android, from the USA (GPVE01) and European (GPVP01) discs:

• 30, 60 and 120 FPS, or your monitor's refresh rate: gameplay keeps the original timing while animations and cutscenes are interpolated
• The original audio engine, with the console's DSP levels
• Console-accurate details: see-through helmet glass with reflections and indirect texture effects (heat haze, geysers, cave holes)
• F1 settings menu drawn with Pikmin 2's own assets
• Randomizer, Speedrun mode with timer and splits, Hard and Permadeath rules, and a captain selector
• Optional mods shared with Pikmin 1: swarm at the cursor, Better Pathfinding, Blues Only In Water, Lock-On and Charge, Eternal Night
• Texture packs, with a one-click HD pack download in the launcher
• Touch controls, touch menus and button icons on Android

Pikmin 1

Functional:

• Native builds for Linux x86-64 and Windows x86-64, Android from the same source
• Most of the game playable from start to finish
• 30, 60 or 120 FPS gameplay, selectable in-game
• Full audio: the game's original JAudio engine, with a software DSP
• TEV specialization for optimal performance
• Controller, keyboard and mouse support, touch controls
• Both retail discs: Pikmin USA Rev 1 and Pikmin Europe. The European disc carries five languages — English, French, German, Spanish and Italian — switchable from the launcher, F1 or the game's own options
• Pre-rendered movies: the attract movies play, with sound
• Widescreen: the HUD is laid out for 16:9 rather than stretched, and the 3D view culls to the same shape, so nothing pops in and out at the sides
• Post-processing: antialiasing, restored fog, bloom, ambient occlusion, depth of field, texture filtering and colour grading — every one of them optional
• Custom texture packs, with a one-click HD pack download in the launcher
• Randomizer: ship parts, enemies and bosses, with share codes
• Nectar Map Maker: an editor for VS arenas, opened from the launcher
• Local co-op: Olimar and Louie, two controllers, split screen that can merge into a single camera; Louie also playable in single player
• HD character models from Pikmin 3 rips
• Per-pixel lighting and real-time shadow maps (Off/Soft/Normal/Strong), both optional
• Launcher: installs, updates itself from GitHub releases, and exposes every F1 setting, texture packs and HD models outside the game
• Speedrun mode: pure GameCube rules, a real-time timer, per-day splits against your best run, categories, LiveSplit support and an input display
• Skippable cutscenes: Start skips any cutscene in normal play

In development:

• Some minor graphical differences

Play directly (without compiling)

Grab the package for your system from Releases.

Linux

Two downloads with the same content; pick one:

• Open_Nectar-x86_64.AppImage — one file. Make it executable (chmod +x Open_Nectar-x86_64.AppImage, or Allow executing as program in its properties) and open it.
• nectar-linux.tar.gz — a folder: tar -xzf nectar-linux.tar.gz, then open nectar-linux/nectar-launcher.

It runs on any x86-64 distribution with glibc 2.29 or newer — Ubuntu 20.04+, Mint 20+, Debian 11+, Fedora, openSUSE Leap 15.3+/Tumbleweed, Arch, Manjaro, SteamOS. SDL2 and the C++ runtime are built into the executables; the system only has to provide an OpenGL driver (any Intel/AMD/NVIDIA one) and, for the file pickers, zenity or kdialog, which GNOME and KDE already have.

Press Install under a game's cover, choose your disc image and a folder. That folder ends up with the game data, your saves and settings, the launcher (nectar-launcher), Pikmin 1 (nectar, for your disc's region), the map editor and, in pikmin2/, Pikmin 2. Install the other game from the same launcher with its own disc. Open that launcher to play from then on. packaging/linux/README.txt in the download covers troubleshooting.

Windows

What you need

• 64-bit Windows
• Graphics drivers with OpenGL 3.3 or newer. Intel, NVIDIA and AMD drivers all provide it. Windows' generic "Basic Display Adapter" driver does not, and the game will not start with it — install your GPU vendor's driver, not the one Windows Update supplies
• About 1 GB free where you install it: the extracted assets take roughly 650 MB, plus the executables

Installing

1. Extract nectar-windows.zip anywhere. There is no installer to run and nothing is written outside the folder you choose.
2. Run nectar-launcher.exe.
3. It asks for your Pikmin disc image, and then for a folder to install into. Any folder works.
4. It verifies the image, extracts the assets and starts the game.

Installation takes a minute or two, most of it verifying that the disc image is intact and that every extracted file came out right. That check catches damaged copies and failing drives, which are the usual reason a game installs fine and then misbehaves later.

ISO/GCM works without additional tools. For RVZ/WIA/GCZ, the launcher uses DolphinTool.exe on Windows or dolphin-tool on Linux from an existing Dolphin installation. It looks beside the launcher and on PATH, then offers a file picker if the tool was not found. Keep the tool with the rest of its Dolphin installation. It is not downloaded or included by Open Nectar.

Conversion needs about 1.4 GiB extra free space in your system's temporary folder. The source image is unchanged; a separate temporary ISO is verified, extracted, and removed when the attempt finishes. An interrupted conversion is never reused. Forced termination may leave a nectar-disc-* temporary folder; remove it only after the launcher and converter have stopped.

The progress display identifies conversion, disc verification, extraction and finishing separately. If setup fails, Back to setup keeps your selections so you can correct the image, converter or destination. Temporary file locks at the final extraction step are retried for up to 2.5 seconds; persistent failures show the preserved extraction path instead of silently starting over.

Once the game starts, F1 opens graphics, controls and gameplay settings.

Playing afterwards

Go to the folder you installed into and run nectar-launcher.exe again, then click the Pikmin cover.

You can also run nectar.exe directly, but only from inside that folder: the game looks for its assets folder relative to the current directory.

Installing without dialogs

From cmd or PowerShell:

nectar-launcher.exe --rom C:\path\to\Pikmin.iso --install-dir C:\Games\OpenNectar

Add --extract-only to install without launching the game afterwards. This works over Remote Desktop and on machines with no desktop session. For a compressed image, add --dolphin-tool C:\path\to\DolphinTool.exe if the converter is not beside the launcher or on PATH. The same option accepts the path to dolphin-tool on Linux.

The console window is intentional

The game opens a console window alongside it, printing what it is doing. It is not an error. This is a young port and those messages are the only thing that explains a failure, so they are left visible on purpose. To keep them:

cd C:\Games\OpenNectar
nectar.exe > log.txt 2>&1

Where your files live

Everything stays in the installation folder:

• save\card0\ — your save files, as ordinary files on disk
• pikmin_settings.conf — the F1 menu settings
• assets\ — the extracted game data

To move the installation elsewhere, use Move Install in the launcher (or copy the folder). To remove it, delete it.

If something goes wrong

Symptom	Cause
SmartScreen warns about the launcher	The .exe files are not signed: More info → Run anyway
"Could not initialize window/OpenGL"	Graphics drivers too old, or the generic Windows display driver
Starts but finds no data	Run it from the installation folder, not from elsewhere
The image is rejected	It must be Pikmin USA Rev 1 or Pikmin Europe. RVZ/WIA/GCZ also needs the Dolphin converter; ISO/GCM does not
Disc conversion fails	Check the temporary folder's free space and select the converter from a complete Dolphin installation, or use ISO/GCM

Android

What you need

• Android 10 or newer on a 64-bit (arm64) device with OpenGL ES 3.0 — in practice, any phone or tablet from 2019 on
• About 1 GB free in internal storage
• Your disc image in ISO/GCM. Compressed images (RVZ/WIA/GCZ) are not supported on Android: convert them to ISO with Dolphin on a computer first

Installing

1. Download open_nectar_<version>.apk from Releases and open it on the device (from the browser's downloads or the Files app). Android asks once to allow installs from that app.
2. Open Nectar. The launcher shows both games: press Install under a cover and pick that game's disc image with the system file picker, from wherever it is (internal storage, SD card, USB).
3. It verifies the image and extracts the assets into the app's private storage. Tap the cover to play.

One APK carries Pikmin 1 and Pikmin 2, each in its USA and European builds; the installer picks the one your disc needs. Touch controls are drawn on screen (every button the game mentions appears in the layout, and the layout button lets you move and resize them); Bluetooth and USB controllers work too. The settings button opens the same menu as F1 on desktop.

To update, install the new APK over the old one — assets and saves stay. Uninstalling deletes them.

Both platforms

The launcher asks for your disc image, extracts the assets it needs and starts the game. Your disc image is never copied or modified.

Supported discs:

Disc	Game ID	Languages
Pikmin USA Rev 1	GPIE01, revision 1	English
Pikmin Europe	GPIP01, revision 0	English, French, German, Spanish, Italian
Pikmin 2 USA	GPVE01	English
Pikmin 2 Europe	GPVP01	English, French, German, Spanish, Italian

Each release needs its own executable — the game's code is compiled here, and it differs between releases — so the package carries both and the installer picks the one your disc needs. The European disc installs all five languages and starts in English; change it in the launcher's Settings, in F1 → Language or in the game's own options, without reinstalling.

The launcher

After installing, the launcher in the game's folder is the way in:

• Games — click a cover to play. Under each cover: Install until the game is installed, then HD textures (downloads the community HD texture pack: 4K or 1080p on PC, the mobile pack on Android) and, for Pikmin 1, Map editor. A single Update below both games updates everything.
• Settings — every option of the in-game F1 menu, plus texture packs, HD models and language, saved straight to pikmin_settings.conf.
• Move Install — moves the whole installation, saves included, to another folder or drive.

When a new release is published, the launcher says so, What's new shows that release's notes, and Update downloads and installs it by itself: saves, settings, texture packs and the extracted game data stay as they are. A newly downloaded package can also update an existing installation: open its launcher, press Update and choose the installed folder. The disc image is not needed either way.

Launcher options

nectar-launcher --rom /path/to/Pikmin.iso --install-dir /path/to/installation
nectar-launcher --extract-only    # extract assets only, don't run
nectar-launcher --help

Build from source

Requirements

• CMake 3.16+
• C++17 compiler (GCC 10+ or Clang 12+)
• SDL2
• OpenGL
• zenity (optional on Linux, for the graphical dialog)

Linux

# Debian/Ubuntu
sudo apt install build-essential cmake pkg-config libsdl2-dev libgl1-mesa-dev zenity

# Arch Linux
sudo pacman -S base-devel cmake sdl2 mesa zenity

# Both games and the launcher
scripts/build-fusion.sh

# Or one game at a time
cmake -S games/pikmin1 -B build/pikmin1 -DCMAKE_BUILD_TYPE=Release
cmake --build build/pikmin1 -j"$(nproc)"
cmake -S games/pikmin2 -B build/pikmin2 -DCMAKE_BUILD_TYPE=Release
cmake --build build/pikmin2 --target pikmin2_pc -j"$(nproc)"

macOS

brew install cmake sdl2-compat
cmake -S games/pikmin1 -B build/pikmin1 -DCMAKE_BUILD_TYPE=Release
cmake --build build/pikmin1 --target pikmin_pc pikmin_launcher -j"$(sysctl -n hw.ncpu)"
cmake -S games/pikmin2 -B build/pikmin2 -DCMAKE_BUILD_TYPE=Release
cmake --build build/pikmin2 --target pikmin2_pc -j"$(sysctl -n hw.ncpu)"

There are no ready-made macOS packages: macOS players build from source.

The Pikmin 1 commands above build the USA game only, so the launcher will ask for nectar-pal when you install a European (PAL) Pikmin disc. To get both next to the launcher, run scripts/build-macos.sh instead: it also builds the PAL game and places it as build/pikmin1/bin/nectar-pal.

The helper builds its own static SDL2 and explicitly selects the USA/PAL build regions, including when reusing an existing build directory. Optionally install libusb with brew install libusb to enable its USB Xbox 360-protocol adapter. That adapter supports one controller at a time and checks for connections and reconnections once per second. Without libusb, standard SDL controller support remains available. The development binaries use Homebrew's libusb when enabled; use the release script for distributable packages.

The compiler comes from the Xcode command-line tools (xcode-select --install). The port requests an OpenGL 4.1 core context, the newest core profile macOS provides.

Choosing which release to build

The game's own code is compiled here, and it is conditional on which retail release it came from in some four hundred places, so this is a build-time choice rather than a setting. Pikmin 1 defaults to USA Rev 1 and Pikmin 2 to Europe:

cmake -S games/pikmin1 -B build/pikmin1-pal -DPIKMIN_GAME_VERSION=VERSION_GPIP01_00
cmake -S games/pikmin2 -B build/pikmin2-usa -DPIKMIN_GAME_VERSION=VERSION_GPVE01

The release packages carry every region, and the launcher installs whichever the disc asks for. scripts/release-linux.sh (tar.gz and AppImage) and scripts/release-windows.sh (zip) build them; the Android APK is ./gradlew assembleRelease in games/pikmin1/android.

Windows (cross-compiled from Linux)

The Windows executable is built with MinGW-w64, cross-compiled from Linux.

SDL2 for MinGW is expected in third_party/SDL2-mingw64. It is not committed to the repository; download SDL2-devel-<version>-mingw.tar.gz from the SDL releases and extract its x86_64-w64-mingw32 directory there, so that third_party/SDL2-mingw64/lib/libSDL2.a exists.

sudo apt install g++-mingw-w64-x86-64

cmake -S . -B build-windows \
      -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-mingw64.cmake \
      -DCMAKE_BUILD_TYPE=Release
cmake --build build-windows -j"$(nproc)"

The result is build-windows/bin/nectar.exe. SDL2 and the MinGW runtime are linked into it (PIKMIN_STATIC_RUNTIME, on by default for Windows), so it needs no DLLs beside it.

To ship a folder with both USA and PAL builds:

packaging/windows/package-standalone.sh

That writes packaging/windows/out/nectar-windows/ with nectar.exe, nectar-pal.exe and nectar-launcher.exe, and zips it as packaging/windows/out/nectar-windows.zip.

Run after building

./build/bin/nectar-launcher --rom /path/to/Pikmin.iso --install-dir ./my-installation

Or, for development directly against a checked-out asset tree in ./assets/:

./build/bin/nectar

Android (APK)

The Android project lives in android/ and builds the game through the same root CMakeLists.txt (both disc versions, GLES, arm64 only). It needs Android Studio's JDK and SDK with NDK 28 and CMake 3.22; android/local.properties points at the SDK.

cd android
JAVA_HOME=$HOME/Android/jdk ./gradlew assembleDebug   # debug-signed, for adb

A release APK is signed with the project key, which is kept outside the repository (see packaging/android/README-firma.txt). With the key in place:

./packaging/android/package-apk.sh

produces packaging/android/out/open_nectar_<version>.apk, its SHA-256 and the README that goes with it.

Project structure

.
├── games/
│   ├── pikmin1/   # Pikmin: decompiled code (src/, include/), port layer
│   │              # (pc_port/), launcher, Android project, packaging
│   └── pikmin2/   # Pikmin 2: decompilation (pikmin2-decomp/) and port layer
│                  # (pc_port/)
├── libs/          # Code shared by both games
├── tools/         # Map maker and development utilities
├── scripts/       # Build and release scripts
├── tests/
└── versions.json  # Release version

• Each game's decompiled code stays as close to the original as possible
• pc_port/ is the native layer that translates GX→OpenGL and handles audio and input; port changes go there

Technical architecture

The port works as follows:

1. Game code (src/) is compiled as a static library
2. Native layer (pc_port/) implements GameCube APIs (GX, AI, PAD, etc.)
3. GX→OpenGL translation: GX display lists are translated to OpenGL shaders
4. TEV specialization: Optimized shaders are generated per material configuration
5. Audio: the game's original JAudio engine runs unchanged; only the boundary where the GameCube's DSP chip used to sit is replaced by a software renderer

Controls and port features

This port includes significant improvements over the original GameCube game, designed to take advantage of keyboard, mouse, and PC capabilities.

Keyboard and mouse

Keyboard (defaults; all of it remappable from the F1 menu):

Action	Key
Movement (left stick)	W A S D
Pikmin formation (C-stick)	T (up) F (left) G (down) H (right)
D-Pad	Arrow keys
A — throw / confirm	Space
B — whistle / cancel	Left Shift
X — dismiss	X
Y — group	Y
Z — change camera	Z
L — rotate camera left	Q
R — rotate camera right	E
Start — pause / skip a cutscene	Enter
Bomb (with Bomb Control on)	B
Port settings menu	F1
Switch control mode	F2
Photo mode	F3

Mouse:

• In pointer mode, the mouse directly controls the game cursor
• Left click: A