Birdman64
Birdman64 is a native PC port of Pilotwings 64 for Windows and Linux that supports widescreen, high refresh rates, and modern gamepads.
- Type: PC port
- Game: Pilotwings 64
- Runs on Windows, Linux and Android
- By NoahVl
- Latest release v1.5.1, 2026-10-21
- Source: https://github.com/NoahVl/Birdman64
README
Birdman64
Pilotwings 64 as a native PC game for Windows and Linux. Widescreen up to 21:9, your monitor's full refresh rate (144 Hz and beyond), modern gamepads, rebindable controls and an in-game settings menu. No emulator: the game's own code, built for your PC from your own cartridge dump (ROM).
Download the latest release, then follow the Quick start. An unofficial fan project; see Legal.
Screenshots
Holiday Island at 1080p, 16:9, 8x MSAA.

Two-player split-screen: both players fly the same test at once, each with their own controller, HUD and score.

The original 4:3 image (left) and Birdman64 at 16:9 (right). Widescreen shows more of the world instead of stretching it.

The rocket belt at 21:9.

A test briefing at 16:9.

On Android (experimental): the same game on your phone, with on-screen controls. The phone builds the game itself on first start.

More screenshots: controls and first-time setup
Every key and button can be rebound in the settings menu.

The one-time setup on first start takes about a minute.

Star History
System requirements
Windows: Windows 10 or 11, 64 bit. A graphics card that supports DirectX 12 or Vulkan (almost every PC from the last ten years); keep the graphics driver up to date: NVIDIA, AMD or Intel. Nothing else to install: no Visual C++ runtime, no .NET, no emulator. An internet connection once, for the one-time setup. About 200 MB of free disk space. A keyboard or a gamepad (Xbox, PlayStation, Switch Pro and most USB/Bluetooth pads work).
Linux: a 64 bit distro from 2022 or newer (Ubuntu 22.04, Fedora 36,
Debian 12, Steam Deck desktop mode, or newer). Vulkan or OpenGL graphics
drivers (Mesa, already installed on most desktops). For the AppImage:
libfuse2 (Ubuntu/Debian: sudo apt install libfuse2; or start it with
--appimage-extract-and-run). Sound uses ALSA/PipeWire (already there on
desktops). Internet once, about 200 MB of disk.
Android (experimental): a 64-bit (arm64) phone or tablet with Android 8
or newer. Sideload Birdman64-android-arm64.apk from the release page and
start it. The first launch builds the game on the device (internet needed
once, about 240 MB installed), then tap Choose a game file and pick your
ROM. Touch controls appear on screen; a gamepad works too. A newer APK
installs over the old one and keeps your saves.
iPhone / iPad (test builds): not on the release page, and no ready-made download: you build the app yourself (free, about 15 minutes, steps below) and install it with your own Apple ID (iLoader recommended); the ROM goes in the Files app under Birdman64. Touch controls and paired controllers work. Installing and testing: the iOS testing guide.
Build the iPhone app yourself:
- No Mac: sign in to GitHub and make a private copy of this
repository: open github.com/new/import,
paste
https://github.com/NoahVl/Birdman64, choose Private and click Begin import. (Please don't use Fork: a fork can't be made private, and anyone can download the builds of a public repository. The app contains the compiled game code, so keep it for yourself.) In your copy, open Actions (enable workflows if asked), pick Build iOS app and click Run workflow. When the run is green, download Birdman64-ios under its Artifacts and unzip it once: that'sBirdman64.ipa. Each build uses some of your account's free GitHub Actions minutes (Mac machines count extra). For a newer version, delete the copy and import it again. - Mac with Xcode: clone this repository and run
packaging/ios/build-ipa.sh; the IPA lands intarget/ios/Birdman64.ipa.
Then install Birdman64.ipa with iLoader and your Apple ID (steps in the
guide above).
macOS: no download yet.
Quick start
- On the Releases page, download
Birdman64-windows-x64.zip (Windows) or the Birdman64
.AppImage(Linux). The other files (debug symbols, checksums) are for bug reports and verification. - Right-click the zip, choose Extract All and open the extracted
folder. Never run
Birdman64.exefrom inside the zip. Keep thetoolchainfolder (the bundled compiler) next to the exe: the first start needs it. - Run
Birdman64.exe(Linux: the AppImage). Windows may show "Windows protected your PC" (SmartScreen, because the program is not code signed): click More info, then Run anyway. - On first start, choose your Pilotwings 64 ROM when the game asks (a
.z64,.n64or.v64file, or a.zipcontaining one; see What's a ROM?). Put the file next toBirdman64.exeand it is found automatically. Only the US (USA) version of the game works. - Wait for the one-time preparation step: the game downloads about 1 MB of the open source decompilation from GitHub and builds it on your machine (a progress window, usually under a minute depending on your PC; it needs about 200 MB of disk space). Internet is only needed the first time. After that the game starts normally every time.
- Play! The first launch shows a card with the basic keys: move with W A S D, A = Space, B = Left Shift, Start = Enter, camera with I J K L, F11 for fullscreen, Esc or F10 for settings.
Controls
Keyboard (defaults; rebind everything on the settings screen's Controls
page, or in pw64.toml under [input.keyboard], for example A = "Space"):
| Input | N64 action | What it does |
|---|---|---|
| W, A, S, D or arrow keys | Control stick | Steer · move in menus |
| Space | A | Confirm · thrust, flap, jump, fire |
| Left Shift | B | Back · gentle thrust, parachute |
| Z or Left Ctrl | Z | Hold to aim camera/missile, release to shoot |
| E | R | Change camera view |
| Enter | Start | Pause · confirm |
| I, J, K, L | C up, C left, C down, C right | Look around |
| T, F, G, H | D-pad | Not used in this game |
| Q | L | Not used in this game |
| Esc | Settings | Open or close the settings screen (when Esc is not bound to a game input) |
| F10 | Settings | Open or close the settings screen |
| F11 or Alt+Enter | Fullscreen | Switch between the window and fullscreen |
Gamepad (Nintendo layout pads match by position, so on a Switch pad the button printed B is the N64 A):
| Input | N64 action | What it does |
|---|---|---|
| Left stick | Control stick | Steer · move in menus |
| South button (Xbox: A, PlayStation: Cross, Nintendo: B) | A | Confirm · thrust, flap, jump, fire |
| West/East buttons (Xbox: X/B, PlayStation: Square/Circle, Nintendo: Y/A) | B | Back · gentle thrust, parachute |
| North button (Xbox: Y, PlayStation: Triangle, Nintendo: X) | C up | Look around |
| Right stick (beyond halfway) | C buttons | Look around |
| Left trigger or ZL (Xbox: LT, PlayStation: L2, Nintendo: ZL) | Z | Hold to aim camera/missile, release to shoot |
| LB / L (Xbox: LB, PlayStation: L1, Nintendo: L) | L | Not used in this game |
| RB / R and RT / ZR (Xbox: RB, RT, PlayStation: R1, R2, Nintendo: R, ZR) | R | Change camera view |
| Start (Xbox: Menu, PlayStation: Options, Nintendo: +) | Start | Pause · confirm |
| D-pad | D-pad | Not used in this game |
| Select (Xbox: View, PlayStation: Create, Nintendo: minus) | Settings screen | Open or close the settings screen |
Features
- Two-player split-screen (top/bottom or side by side) with every vehicle, bonus game and Free flight; pick 2 Players on the title menu
- Widescreen by default on wide monitors (any ratio up to 21:9, menu backgrounds stay 4:3 by design); fill the screen without letterbox bars
- Window, borderless fullscreen or exclusive fullscreen with a chosen video mode
- High frame rate: runs at your monitor's refresh rate, 144 Hz and beyond
- MSAA (1x, 4x, 8x) and render scale (supersampling or upscale) with a linear or nearest filter
- The N64's 3-point texture filter (set the filter to
n64, seePW64_FILTERbelow) - Texture packs: PNG folders keyed by texture content hash, in your data
dir's
packsfolder — pick one under Settings > Display & graphics > "Texture pack" (a restart applies it) or open the folder from the game with "Open texture packs folder" - Optional V-Sync style pacing to remove judder
- OLED care: the HUD drifts and the screen dims a little to spread wear
- Gamepads (including Switch 2 controllers over Bluetooth, experimental)
- An in-game settings screen (F10, Esc or pad Select) that rebinds every
key and button and saves to
pw64.toml - An "Unlock everything" cheat on the settings screen: gold medals on every test, every class, the bonus games and Birdman (your save is backed up first and can be restored from the same screen)
- One-time setup that builds the game from your own ROM: nothing but our own code ships in the download
How it was made
Birdman64 went from an empty repository to a 1.0 release in six days (27 September to 3 October 2026). NoahVl designed and led it, directing a team of AI coding agents:
- Orchestrator and workers: a lead agent (Claude Opus 5.5) plans the work, delegates it and reviews every change. A fast, low-cost model (GLM 5.3-Flash) runs the routine tasks in parallel and wrote 44% of the commits, which keeps the expensive model for architecture, debugging and review.
- Human in the loop: product and design decisions, legal ground rules, and play-testing every build.
- Verified, not trusted: CI on Windows and Linux with warnings as errors, 321 tests, and scripted flights whose frames are checked before a change lands.
The result: about 47,000 lines of Rust in 12 crates and roughly 250 commits. That covers a replacement for the N64 operating system, graphics and audio engines, asset tools and a one-click launcher. The design notes are the agents' shared memory, so every session picks up where the last one stopped.
Settings and files
Settings screen: press F10, Esc (or pad Select) to pause the game and change options. Changes are saved when you close the screen; volume and most graphics options apply immediately, a few (MSAA, widescreen, fill screen, infinite LOD, infinite view distance) are marked "(restart)" and need the game restarted to apply. Reset rows restore the defaults.
pw64.toml example (all keys optional, the same options exist as
environment variables):
[graphics]
msaa = 4 # 1, 4 or 8
scale = 2.0 # render scale, 0.5 or more (1 = window size)
scale_filter = "linear" # or "nearest"
filter = "n64" # N64 3-point texture filter, or "bilinear"
widescreen = "16:9" # 1, "w:h", a ratio like "2.33", or 0 (off)
fps = "monitor" # "monitor", 30..1000, or 0 (uncapped)
vsync = false # display-paced pacing (less judder, more latency)
display_mode = "windowed" # "windowed", "borderless" or "exclusive"
fullscreen_resolution = "1920x1080@60" # exclusive video mode WxH[@Hz]
linux_window = "auto" # Linux: "auto", "wayland" or "x11"
show_fps = false # frame rate in the window title
infinite_lod = false # models at full detail at any distance (restart)
infinite_view_distance = false # see the whole island (restart; costs frame time)
no_audio = true # no audio output device
volume = 0.8 # 0.0..1.0
[input.ble]
enabled = true # Switch 2 pads over Bluetooth LE
[oled]
drift = false # HUD drift for OLED burn-in care
brightness = 1.0 # 1.0, 0.85, 0.8, 0.75 or 0.7
[ui]
pause_in_background = true # pause when you switch windows or unplug the controller
Where files live: everything goes in one folder. How that folder is chosen is described under Save files below.
The one-time setup cache (the downloaded decompilation and the compiled game
module) lives in a cache folder next to them: next to the exe in a portable
install, else %LOCALAPPDATA%\Birdman64\cache (Windows) or ~/.cache/birdman64
(Linux). The Linux AppImage always uses the per-user locations above. Deleting
the cache is safe: the next start just builds the game once more.
Save files: the folder holds the save (pw64.eep), the settings
(pw64.toml) and crash.log. It is chosen once at start, in this order: the
PW64_DATA_DIR environment variable when set; next to the exe when that
folder holds portable.txt or pw64.eep and is writable
(portable use, for example on a USB stick: create an empty portable.txt
there; a folder like C:\Program Files is not writable); otherwise the
per-user folder, %APPDATA%\Birdman64 (Windows) or
$XDG_DATA_HOME/birdman64, else ~/.local/share/birdman64 (Linux). A fresh
extraction has no marker next to the exe, so it uses the per-user folder:
updating stays a matter of unzipping the new version anywhere, and saves,
settings and the remembered ROM carry over. The Linux AppImage always uses
the per-user location. The start-up log prints [paths] data dir: <path> with
the folder that was chosen. To edit pw64.toml by hand, open that folder from
the settings screen ("Open save folder"); outside a portable install, a
pw64.toml placed next to the exe is not used.
The save itself, pw64.eep, is a raw N64 EEPROM image: no header and no byte
swapping (unlike .v64 ROM files). It is written as 2048 bytes. The game's
two save files sit at offsets 0x000 and 0x100 inside it (Birdman64 emulates a
4 Kbit EEPROM, so the first 512 bytes are the part the game uses).
Moving a save between devices (PC ↔ Android): open the pause menu and pick
"Export save…" on the device that has the save, save the file somewhere you can
reach from the other device (cloud drive, USB cable, messaging app to yourself),
then pick "Import save…" there and choose it. The game restarts with the new
save; the one it replaced is kept as pw64.eep.before-import. The file is the
same pw64.eep on every platform.
Using an emulator save: quit Birdman64 and back up your pw64.eep first,
then copy the emulator's save file over it. A Project64, mupen64plus or
simple64 .eep file (512 or 2048 bytes) works as it is. A RetroArch
Mupen64Plus-Next .srm file starts with the EEPROM contents, so a copy
renamed to pw64.eep works too (only the first 2048 bytes are read; the next
save writes a 2048-byte file). To go back to an emulator, copy pw64.eep
under the emulator's save file name, or set PW64_EEP=<path> and Birdman64
uses (and updates) that file directly. Never replace the save file while the
game is running: the game keeps the save in memory and overwrites the whole
file at the next save.
Useful environment variables for players: every option in pw64.toml
also exists as a PW64_* environment variable, which wins over the file
when both are set:
| Variable | Effect |
|---|---|
PW64_MSAA=<1|4|8> | MSAA sample count (restart) |
PW64_SCALE=<f> | render resolution as a fraction of the window (below 1 upscales) |
PW64_SCALE_FILTER=<linear|nearest> | filter for the blit when the render resolution differs |
PW64_FILTER=<bilinear|n64> | texture filter (the N64 look is n64) |
PW64_WIDESCREEN=<1|w:h|0> | widescreen aspect; the default is your monitor's aspect when it is wider than 4:3 (up to 21:9) |
PW64_FILL_SCREEN=<0|1> | no letterbox bars around world views (default: follows widescreen) |
PW64_INFINITE_LOD=<0|1> | models at full detail at any distance (restart) |
PW64_INFINITE_VIEW_DISTANCE=<0|1> | see the whole island instead of fading out after ~2 km (restart) |
PW64_FPS=<monitor|N|0> | frame rate (uncapped with 0) |
PW64_VSYNC=<0|1> | display-paced pacing (V-Sync) |
PW64_DISPLAY_MODE=<windowed|borderless|exclusive> | window, borderless fullscreen or exclusive fullscreen |
PW64_FULLSCREEN_RES=WxH[@Hz] | the exclusive fullscreen video mode |
PW64_LINUX_WINDOW=<auto|wayland|x11> | Linux: native Wayland or X11 (XWayland) window; auto uses X11 on hybrid NVIDIA laptops |
PW64_OLED=<0|1> | HUD drift and dimming for OLED screens |
PW64_BLE=<1|0> | Switch 2 controllers over Bluetooth LE |
PW64_ROM=<path> | which ROM file to use |
PW64_DATA_DIR=<path> | folder for saves and settings |
PW64_EEP=<path> | exact save file to use instead of pw64.eep |
PW64_TEX_PACKS=<dir> | replace textures from a PNG pack (overrides the in-game "Texture pack" setting) |
PW64_NO_AUDIO=1 | run without an audio device |
The developer variables live in Developing.
What's a ROM?
A ROM is a copy of the game cartridge's data, made with a cartridge dumper from a cartridge you own. We can't provide or link one. Birdman64 needs the US version of Pilotwings 64: Troubleshooting shows how to check which file you have.
Updating
Download the new zip and extract it anywhere. Saves, settings and the
remembered ROM live in your user folder (see Save files above), so the
new version picks them up automatically. Keep the toolchain folder next
to the exe: the first start of the new version rebuilds the game once,
briefly showing the setup screen again.
Uninstalling
Delete the folder you extracted, then delete the per-user folder:
%APPDATA%\Birdman64 and %LOCALAPPDATA%\Birdman64 on Windows,
~/.local/share/birdman64 (or $XDG_DATA_HOME/birdman64) and
~/.cache/birdman64 on Linux. That removes your saves and settings too,
so back up pw64.eep first if you want to keep them.
Troubleshooting
- "The ROM does not work" or the game refuses to start: only the US (USA) version of Pilotwings 64 is supp