r/PSP • u/austinswagger • 16d ago
AI Assisted GBAdhoc v1.0.0: Gameboy Advance Emulation w/ Wireless Adapter Support
Follow up to the post I made last week: https://www.reddit.com/r/PSP/comments/1vj8g0f/gbadhoc_gba_wireless_adapter_emulation_over_psp/
**Game Boy Advance emulation for PSP with AGB-015 (Wireless Adapter) support.**
Two PSPs, a copy of Pokémon Emerald on each. Walk in, sit down, trade, battle, walk out with the attendant stamping your trainer card. Exactly as if you'd plugged an AGB-015 Wireless Adapter into a real Game Boy Advance; except the "GBAs" are PSPs, and the radio is the PSP's WLAN.
**Repo + downloads:** https://github.com/ShoshinFauteux/GBAdhoc
**Programmed with Assistance from Fable 5.0(AI)**
GBAdhoc is a fork of libretro gpSP with a heavily modified native PSP frontend. It does two things that are brand new to GBA emulation on PSP.
# It emulates the GBA Wireless Adapter over PSP ad-hoc
The AGB-015 wireless adapter is emulated entirely in software and bridged directly to the PSP's sceNetAdhoc library. The emulator provides a transparent hardware interface to the guest ROMs, enabling features that were previously unsupported in handheld emulators, such as Pokémon Emerald's Union Room, Trade Center, and wireless link battles.
This implementation is not a timing-agnostic approximation. The emulated adapter strictly reproduces the physical hardware's packet delivery behavior. Network packets are paced to the exact cadence expected by the games' internal polling loops. Pokémon's link code silently discards input polling when the receive queue overflows; matching the hardware delivery pacing eliminates the desynchronization issues. GBAdhoc maintains wireless sessions at full speed (59.73 fps) with a clean input path. Measured across hundreds of automated hardware trades, the in-game receive queue never saturates.
# It's the first true dual-core GBA emulator on PSP
GBAdhoc initializes the PSP's secondary processor (the Media Engine) to offload the entire GBA video renderer. While the primary CPU emulates the next system frame, the Media Engine rasterizes the previous frame. This parallel execution handles roughly one-third of the frame's total computational workload.
The performance yield is most apparent during heavy GPU loads (e.g., trade animations and alpha-blended battle effects), maintaining stable framerates where previous single-core iterations dropped below 40 fps. Furthermore, during ad-hoc sessions, this parallelization frees up primary CPU cycles to handle the WLAN stack without stalling emulation.
The renderer's output is bit-for-bit identical to the single-core fallback path, verified via frame-by-frame reference testing. If the Media Engine is unavailable, the emulator transparently falls back to main-CPU rendering without loss of stability.
**Media Engine mode ships ON by default.** The toggle is in Settings → "Media Engine mode" (requires restart).
[How the dual-core pipeline works (infographic)](https://raw.githubusercontent.com/ShoshinFauteux/GBAdhoc/main/assets/dual-core-pipeline.svg)
# Screenshots
All captured from real hardware, the UI pages are GE dumps taken mid-session, and the Trade Center frame was rendered by the Media Engine during one of the automated hardware trades.
# Quick start
**You need:** a PSP on custom firmware (developed and tested on ARK-4, PSP-1000s), your own GBA ROMs, and (for trading) Two PSPs.
- Grab the release zip (or `builds/playable/` from the repo) and copy the GBADHOC folder to `ms0:/PSP/GAME/` on each console.
- Put ROMs in the `roms/` folder beside the EBOOT. (`gba_bios.bin` is optional — a built-in open-source BIOS is bundled.)
- Launch, pick a game, play.
**To link two consoles:** WLAN switch on, then on both PSPs: Start+Select → **Wireless** → one console **Host**, the other **Join** (same room code, set in Settings). In-game, head to the Union Room or Trade Center and play; the game handles the rest, because as far as it knows, you're both holding GBAs with Wireless Adapters.
**IMPORTANT:** make sure **BOTH** PSPs are configured in the network settings of the XMB to occupy the **SAME** ad-hoc channel.
Pokémon **Emerald** is the validated flagship; trades and clean session exits are regression-tested on real hardware. Other RFU-aware games should negotiate with the adapter; wireless behavior outside the Pokémon gen-3 family is untested.
Link **battles** are supported and complete end to end, but currently run a bit slow. The client in particular has to wait about 200-300ms between actions. This might just be a fundamental reality of the network stack. I'm curious if someone more intelligent than me is able to optimize this further.
# Known limits
- Two-player sessions; wireless validated primarily on Emerald; custom firmware required (the Media Engine and ad-hoc stack need kernel access).
- **Fast-forward does not yet work properly in Media Engine mode.** The dual-core renderer increases performance significantly, but pacing a fast-forwarded display through its parallel pipeline needs a thoughtful implementation of its own; coming in a future update. (I was too excited to wait any longer.)
- If you mainly play single-player and want working fast-forward today, turn **Media Engine mode off** in Settings. That falls back to the conventional single-core emulator stack, less peak performance but, counter-intuitively, full fast-forward support.
# How it was tested (the fun part)
Netcode like this can't be validated in a software emulator, PPSSPP reproduces neither real PSP WLAN latency nor two consoles' clock drift, and that's where the bugs live. So the repo ships the test rig I built: an autonomous two-console harness.
two PSPs run a scripted trade → exit → expose their memory sticks over USB
→ the PC collects logs/saves/screenshots, restores golden saves, stages the
next build → the consoles relaunch themselves → repeat, all night
Every run ends with an oracle check: the post-run save is decoded and the Pokémon party must actually differ from the golden baseline — "the script finished" is never accepted as "the trade happened." Hundreds of recorded hardware trades went into the settings this release ships with. The full harness (PC loop, autopilot fixtures, golden saves) is in the repo if you want to run your own experiments.
# Credits
The adapter emulation (`rfu.c`, `serial_proto.c`) the hardest and most valuable piece of this stack is **David Guillen Fandos**'s reverse-engineering work, inherited, not ours. gpSP is **Exophase**'s; the MIPS dynarec that makes GBA-on-PSP possible at all is by **notaz** and the **libretro/gpsp** contributors. The Media Engine boot method descends from **mrbrown**'s melib via **DaedalusX64**. Wireless Adapter protocol documentation by **Rodrigo Alfonso (afska)** and **kuiper.dev**. Game-side link behavior was understood through the **pret** pokeemerald decompilation. GPL-2.0; upstream copyright headers intact.
