How to Set Up BGB for Pokémon Red, Blue & Yellow [2026]

Pokémon Red, Blue, and Yellow are the games that started the franchise, and the emulator most Generation I players, speedrunners, and researchers reach for on PC in 2026 is BGB. It isn’t the newest emulator on the market — the project has been around for decades — but it is still actively updated, with version 1.6.6 shipping in July 2025 and remaining current through 2026. This tutorial covers a complete BGB setup for Pokémon Red, Blue, and Yellow, including the debugger, link cable trading, palette customization, save states, and the RNG-related quirks that make BGB different from other Game Boy emulators.

BGB occupies a specific niche most general-purpose emulators don’t: it was built by and for the Game Boy development community, so it ships with a real debugger, a disassembler, and memory inspection tools most players never touch but that make it the emulator of choice for anyone practicing frame-perfect resets or studying how Gen 1’s internal RNG actually behaves. If you just want to play through Kanto casually, BGB still does that well — the extra tooling simply sits there unused until you need it.

This guide assumes no prior emulation experience and walks through every stage of a working setup: getting BGB installed on Windows (and, for Linux and macOS users, through Wine), loading a legally dumped ROM, mapping controls, configuring save states and speedup, setting up link cable trading between two versions, and troubleshooting the handful of issues that come up most often. By the end, you’ll have a fully configured, verified BGB install ready for a casual playthrough, a Nuzlocke, or deeper RNG study.

What You’ll Need: Prerequisites and Versions

BGB is a small, lightweight download with modest system requirements — the entire emulator is a fraction of the size of a single modern app icon.

Requirement	Minimum Spec / Version	Notes
BGB version	1.6.6 (released July 20, 2025, current through 2026)	Download only from the official bgb.bircd.org — do not use third-party mirrors
Operating system	Windows (32-bit and 64-bit native builds)	No official Linux or macOS build; both run BGB via Wine, which is common practice but unofficial
CPU/GPU	Any x86 chip from the last 20 years	Game Boy emulation is trivially light on modern hardware
RAM	512MB free	BGB’s own footprint is measured in single-digit megabytes
Storage	Under 5MB for the emulator itself	ROM and save files add negligible space on top
ROM files	Legally dumped .gb files (Red, Blue, or Yellow)	You must own the physical cartridge to dump it yourself
Wine (Linux/macOS only)	Recent stable Wine release	Only needed if you’re not running native Windows

BGB is freeware — there’s no purchase price, no license key, and no account requirement. Every feature covered in this guide, including the debugger and link cable emulation, is available in the free download.

Step 1: Download BGB From the Official Site

Go to bgb.bircd.org/downloads.html and pick the win32 or win64 build of version 1.6.6, matching your system. The download is a small ZIP archive rather than an installer — there’s nothing to run and accept through a setup wizard.

On native Windows, extract the ZIP anywhere convenient and run bgb.exe directly. On Linux or macOS, install Wine first and run BGB through it:

# Linux (Debian/Ubuntu example)
sudo apt install wine
mkdir ~/Emulators/bgb
cd ~/Emulators/bgb
unzip ~/Downloads/bgb166.zip
wine bgb.exe

On macOS, the equivalent path uses Homebrew to install Wine, then the same unzip-and-run pattern:

# macOS (Homebrew example)
brew install --cask wine-stable
mkdir -p ~/Emulators/bgb && cd ~/Emulators/bgb
unzip ~/Downloads/bgb166.zip
wine bgb.exe

Performance under Wine is essentially identical to native Windows for a Game Boy emulator this light, so there’s no real downside to running it this way on non-Windows systems.

Step 2: First Launch and Interface Orientation

BGB opens to a small, plain window — a stark contrast to more modern emulator UIs. The menu bar across the top holds File, Emulator (which houses most settings), Video, and Tools, plus a Help menu with the full manual built in. This minimal look is intentional: BGB was designed as a development tool first, a player-facing emulator second, so the interface prioritizes function over polish.

Before loading a ROM, open Options under the Emulator menu to see the layout of settings you’ll touch throughout this guide: Joypad (controls), Sound, Misc (BIOS, speed, palettes), and Emulator core options like the “detect GBA” toggle discussed later.

Step 3: Load Your First Pokémon ROM

Go to File > Open ROM (or Ctrl+O), navigate to your dumped .gb file, and select it. BGB boots straight into the game with no additional configuration required — save type and hardware detection are handled automatically.

Organize your ROM folder like this to keep saves and states tidy across all three Gen 1 versions:

Pokemon-Gen1/
  Pokemon-Red.gb
  Pokemon-Red.sav
  Pokemon-Blue.gb
  Pokemon-Blue.sav
  Pokemon-Yellow.gb
  Pokemon-Yellow.sav
  states/
    (BGB save states land here by default, alongside the ROM)

BGB writes .sav files next to the ROM by default. If you’d rather keep everything centralized, set a custom path under Options > Misc, though most players find leaving the default location alone is simpler for a small three-game library.

Step 4: Verify Your ROM Before Long Play Sessions

Gen 1 ROMs are old enough that bad dumps and mistranslated hacks circulate widely. A quick checksum check before committing hours to a playthrough or a shiny-adjacent breeding project (Gen 1 has no shinies, but the same RNG mechanics apply to stat and move-based manipulation) saves a lot of frustration later.

# Windows PowerShell
Get-FileHash "Pokemon-Red.gb" -Algorithm SHA1

# Linux / macOS (or inside Wine's underlying shell)
sha1sum Pokemon-Red.gb

Compare the resulting hash against a known-good dump list. A mismatch doesn’t automatically mean corruption — different regional revisions produce different hashes — but it’s worth testing the ROM through several key story beats (Mt. Moon, the S.S. Anne, the first Gym) before trusting it with real playtime.

Step 4b: Why BGB’s Accuracy Matters for Gen 1 Specifically

Pokémon Red, Blue, and Yellow are notorious for glitches that depend on precise hardware behavior — the Missingno encounter via the Old Man/Cinnabar Coast trick, the Mew glitch involving a trainer sight line and an item swap, and dozens of smaller memory-overflow exploits that speedrunners and researchers rely on. These only reproduce reliably on an emulator that matches original hardware timing closely. The GBDev community’s own documentation lists BGB among the emulators built specifically around this kind of precision, which is why it remains the reference tool for understanding exactly why a given Gen 1 glitch works rather than just that it works.

For a casual player this distinction rarely matters day to day, but it explains why BGB has stayed relevant for over two decades while flashier, more feature-heavy Game Boy emulators have come and gone. If you ever want to reproduce a documented Gen 1 glitch exactly as described in a walkthrough, BGB is the emulator those walkthroughs were almost certainly tested against.

Step 4c: Handling ROM Hacks and Patched Gen 1 Games

If you’re running a Gen 1 ROM hack rather than the original retail game, BGB itself doesn’t apply patches — you’ll need a separate patcher first, then load the resulting file the same way as any other ROM. IPS is the most common patch format for older Game Boy hacks specifically, since it predates the newer UPS and BPS formats used more often for GBA-era projects.

Confirm which base ROM revision the patch expects (region matters — a patch built against a US Red ROM will typically fail against a Japanese or European dump)
Use a dedicated IPS patcher (Floating IPS/Flips handles Game Boy-era patches as well as GBA-era ones) to apply the patch to a copy of your base ROM
Keep the original, unpatched ROM in a separate folder in case the hack updates later and needs a clean base again
Load the patched output file into BGB through File > Open ROM as normal

Save compatibility between patch versions of the same hack isn’t guaranteed, so treat a major hack update as a fresh start unless the hack’s own documentation specifically states otherwise.

Step 5: Configure Controls

Go to Options > Joypad to remap keyboard or controller input. BGB defaults to arrow keys plus Z/X for A/B, which is functional but worth adjusting if you’re used to a different layout from other emulators. BGB supports DirectInput controllers, so a standard Xbox or generic USB gamepad will show up automatically once connected.

Game Boy Button	BGB Default Key	Suggested Gamepad Mapping
A	Z	Face button (bottom)
B	X	Face button (right)
Start	Enter	Menu/Start
Select	Backspace	View/Back
D-Pad	Arrow keys	D-Pad

Since Gen 1 involves heavy menu navigation (the notoriously clunky item bag included), spend a minute confirming Select and Start feel natural before starting a real playthrough — they’re used constantly for menu switching in battle.

Step 6: Set Up Save States

Save states in BGB work through the File menu or default hotkeys, capturing the full emulated state rather than relying on the game’s own save system. This is especially useful in Gen 1 given how few in-game save points effectively exist outside the menu-based save option.

Shift+F1 through Shift+F10 create a save state in one of ten slots
F1 through F10 load the corresponding slot
File > save state / load state gives you a slot picker if you’d rather not memorize hotkeys

If you’re practicing a specific segment — a Gym fight, a Mt. Moon Zubat gauntlet, a specific trainer battle — save states let you reset to that exact point repeatedly without replaying everything before it.

Step 7: Enable Speedup for Grinding

Gen 1’s level curve and the total absence of an EXP Share equivalent (it exists but works differently than in modern games) makes grinding a real time sink. BGB’s speedup control, found under Options or bound to a hotkey, lets you fast-forward through repetitive battles and travel without altering audio pitch as dramatically as some older emulators do.

Set your preferred multiplier once and it persists across sessions, so you don’t need to reconfigure it every time you reopen BGB for a new play session.

Step 8: Emulate Link Cable Trading Between Red, Blue, and Yellow

A full Gen 1 Pokédex requires trading — Machoke to Machamp, Graveler to Golem, Haunter to Gengar, Kadabra to Alakazam all need a trade to evolve, and each version has exclusives (Ekans/Koffing in Red vs. Sandshrew/Vulpix in Blue, with Yellow drawing from both pools differently). BGB supports link cable emulation between two instances, either on the same PC or over a network connection.

Launch two BGB windows, each loaded with a different Gen 1 version
In each window, go to the link cable option under the Emulator menu
Set one instance to listen and the other to connect (localhost for same-machine trades, or a LAN IP for two separate computers)
In-game, walk each character to a Pokémon Center and use the connected cable option in the same way you would on original hardware

For trades across two physical machines, both need to be reachable on the same network with any relevant firewall exception in place — the same networking prerequisite that trips up link cable setups on most other Game Boy-family emulators.

Step 9: Customize Palettes for Non-Color Cartridges

Red and Blue were designed for the original monochrome Game Boy, so by default they render in shades of green or grey. BGB’s “reality” feature set, expanded through the 1.6.x release branch, adds hardware-accurate color simulation modes that mimic the actual LCD look of the original Game Boy (DMG) and, separately, the Game Boy Pocket’s slightly different screen tint, sampled specifically for the 1.6.3 update.

To change this, go to Options > Misc > palette and choose between the available presets: greyscale, a Game Boy Color-style tinted palette (common for Yellow, which supported limited GBC coloring on real hardware), or one of the DMG/Pocket “reality” modes for an authentic screen look. This is purely cosmetic and has no effect on gameplay or RNG behavior.

Step 10: Understand BGB’s Role in RNG Manipulation and Speedrunning

Gen 1’s random number generator is deterministic and well documented by the speedrunning community, and BGB is widely used for practicing RNG manipulation thanks to its debugger and frame-accurate controls. One setting matters specifically here: BGB includes a “detect GBA” option that makes its behavior match a Game Boy Advance running the game in backward-compatibility mode rather than an original Game Boy, since GBA-era RNG manipulations differ slightly from original-hardware manipulations.

One important caveat worth knowing before you invest practice time: BGB itself is commonly used for research, practice, and RNG experimentation, but it is not the emulator accepted for verified leaderboard speedrun submissions — that role belongs to Gambatte-speedrun, a different, purpose-built core. Treat BGB as a practice and study tool for Gen 1 RNG mechanics rather than a submission-ready recording environment if competitive speedrunning is your goal.

What makes Gen 1’s RNG approachable for this kind of study is that it’s fully deterministic given the same starting state and inputs: the same save file, the same hard reset, and the same sequence of button presses will reproduce the same in-game outcomes every time. That’s what makes manipulation possible in the first place — players and researchers work backward from a desired outcome (a specific wild encounter, a favorable critical hit, a particular stat roll) to the exact sequence of resets and inputs that produces it, then practice executing that sequence consistently. BGB’s frame-accurate save states and speedup make this kind of iterative practice dramatically faster than attempting the same research on original hardware.

Step 11: Use the Built-In Debugger (Optional, for Advanced Users)

BGB’s debugger, accessible through the Tools menu, sets it apart from nearly every other Game Boy emulator. It includes breakpoints, single-step execution, a disassembler, and direct memory inspection — tools built for ROM hackers and developers, not casual players, but genuinely useful if you want to understand exactly what’s happening under the hood during a specific in-game event.

For a Pokémon-specific use case, the debugger lets you watch memory addresses tied to the RNG seed update each frame, which is how serious RNG manipulation guides for Gen 1 are built in the first place. This is entirely optional for a normal playthrough — most players will never open this menu — but it’s there if your interest goes beyond casual play.

Step 12: Verify Your Setup Is Working Correctly

Run through this checklist before committing to a full playthrough:

Check	Expected Result
Boot to title screen	Game loads within a few seconds with no black screen or crash
Save and reload	In-game save persists after closing and reopening BGB
Controls respond	All mapped keys or gamepad buttons register correctly in-game and in menus
Audio plays without distortion	No crackling or pitch issues at normal speed
Speedup toggles cleanly	Fast-forward engages and disengages without freezing the emulator

If everything on this list checks out, you have a fully functional BGB setup ready for a full Kanto playthrough, competitive-team breeding, or RNG research.

Common Pitfalls When Setting Up BGB for Pokémon

These are the mistakes that generate the most confusion among first-time BGB users coming from more modern, GUI-heavy emulators.

Expecting a modern, polished interface. BGB’s UI hasn’t changed dramatically in years by design — it’s a stability and accuracy-focused tool, not a showcase app. This is normal, not a sign something installed incorrectly.
Downloading BGB from a third-party mirror. Always use bgb.bircd.org directly. Because BGB isn’t distributed through app stores, mirror sites bundling extra installers are a real risk.
Assuming Linux/macOS support is official. Wine compatibility is community-tested and works well, but there’s no native BGB binary for either platform — don’t expect official support threads to cover Wine-specific issues.
Mixing up “detect GBA” for a normal playthrough. This option is specifically for RNG manipulation research matching GBA-era behavior. Leave it off for a standard playthrough unless you’re specifically studying GBA-compatible RNG manipulations.
Treating BGB as leaderboard-legal for speedrun submissions. If competitive submission is your goal, you’ll need Gambatte-speedrun instead — use BGB for practice and study.
Forgetting that Gen 1 trade evolutions require two running instances. A single BGB window can’t simulate a link cable trade by itself; you need two separate instances connected to each other.
Overwriting a save by loading the wrong regional revision. As with any Game Boy title, mixing ROM revisions on the same save file can cause corruption. Stick to one revision per save file.

Example Output: What a Correct Setup Looks Like

A properly configured BGB session running Pokémon Yellow should show something like this in the title bar and Options panels:

BGB 1.6.6 — Pokemon-Yellow.gb
Core: Game Boy Color compatible
Palette: GBC-style (auto-detected for Yellow)
Speed: 100% (1x), speedup bound to Tab
Save: Pokemon-Yellow.sav (auto-saved on write)
Joypad: Mapped, 8/8 inputs bound
Link: Idle (ready to host or connect)

If the palette shows greyscale for Yellow when you expected GBC-style color, double check the palette setting under Options > Misc — Yellow supports limited color on real GBC hardware, and BGB can replicate that if the palette mode is set correctly.

Troubleshooting Common BGB Issues

Here are the issues that come up most often, along with what actually fixes them.

BGB won’t launch on Linux/macOS. Confirm Wine is installed and up to date; older Wine builds can fail on some of BGB’s OpenGL rendering paths introduced in the 1.6.x branch.
Black screen after loading a ROM. Usually a corrupted or incompatible dump. Re-verify the ROM’s checksum and try a different known-good dump if available.
Save file doesn’t persist after closing BGB. Check that BGB has write permission to the ROM’s folder, and make sure the ROM wasn’t loaded from a read-only location or an unextracted archive.
Graphics stutter on a multi-monitor Windows setup. This was a known issue in earlier 1.6.x builds; the 1.6.6 release specifically addressed non-smooth graphics and OpenGL stuttering on multi-monitor Windows 10 systems, so confirm you’re on the latest version first.
Unicode filenames cause a ROM to fail loading. This was a regression introduced in 1.6.5 and fixed in 1.6.6 — update if you’re on an older build and hitting this specifically.
Link cable connection times out between two PCs. Confirm both machines are on the same network segment, disable firewalls temporarily to test, and make sure both instances are running the same BGB version.
Controller not recognized. BGB uses DirectInput; reconnect the controller before launching BGB, and confirm Windows itself recognizes the device in its own game controller settings first.
Debugger single-stepping feels extremely slow. Large symbol files can slow single-stepping in the debugger — this was specifically fixed in 1.6.6, so update if you’re hitting this on an older release.
Speedup doesn’t seem to change anything. Confirm the hotkey is correctly bound under Options and that you’re holding rather than tapping it, depending on how you configured the toggle.
Palette looks wrong for a Red or Blue cartridge. Red and Blue are DMG-only titles with no native color support — a colorized look means you’ve selected an artificial recoloring palette rather than an authentic greyscale mode, which is fine but worth knowing is a stylistic choice, not a bug.

Advanced Tips: Getting More Out of BGB

Once your basic setup is solid, a few of BGB’s less obvious features are worth exploring.

Configuration file switching via the -ini flag. BGB 1.6.6 added a command-line “-ini” parameter that lets you launch the emulator with a different configuration file, useful if you maintain separate BGB setups for casual play versus RNG research with different debugger and palette settings.

SGB (Super Game Boy) link transfer logging. The debugger includes a persistent “log link transfers to SGB window” option, useful if you’re studying exactly what data passes between two linked instances during a trade.

Save state slots as a manual bookmark system. With ten available slots, you can treat states as checkpoints at every Gym, every key item pickup, or every major story beat, giving you a navigable history through a playthrough beyond what the game’s own single in-game save allows.

Cross-referencing with PKHeX for save editing. BGB itself doesn’t include a save editor, but Gen 1 .sav files it produces are readable by dedicated tools. If you want to inspect or edit stored Pokémon data directly, see our guide on how to use PKHeX to edit Pokémon saves.

Complete Working Project: A Full Pokémon Yellow Setup From Scratch

Here’s the full sequence for going from a blank Windows machine to a fully configured, controller-mapped BGB setup running Pokémon Yellow.

# 1. Download BGB 1.6.6 (win64) from bgb.bircd.org/downloads.html

# 2. Extract to a permanent folder
#    C:EmulatorsBGBbgb.exe

# 3. Create a clean ROM folder
#    C:GamesPokemon-Gen1Pokemon-Yellow.gb

# 4. Launch bgb.exe

# 5. In the GUI:
#    File > Open ROM > select Pokemon-Yellow.gb
#    Emulator > Options > Joypad > map keyboard or gamepad
#    Emulator > Options > Misc > set palette to GBC-style
#    Emulator > Options > set speedup hotkey and multiplier
#    Shift+F1 to create your first save state as a checkpoint

# 6. Verify:
#    Title screen loads within seconds
#    Save via in-game menu persists after closing and reopening BGB
#    Controls register correctly in the Options test screen

At this point you have a fully playable Pokémon Yellow setup with GBC-style coloring, mapped controls, save states as checkpoints, and speedup ready for grinding. The identical sequence works for Red and Blue — just swap the ROM filename and, if you want the DMG-authentic look those two versions were designed for, switch the palette to greyscale or one of BGB’s “reality” modes instead of GBC-style.

Understanding Gen 1’s Save System and Why It’s Fragile

Gen 1’s original save system is a known weak point of the hardware generation, and it’s worth understanding before you build an emulated setup around it. The game keeps a single save slot backed by battery-powered SRAM on the original cartridge, and the games only checksum-validate that save when loading — a corrupted write can silently sit undetected until you next load the game and find your progress reset. BGB reproduces this same save behavior faithfully, which is accurate to the original hardware experience but means the same fragility applies in emulation.

Two habits reduce risk substantially: always let the game finish writing (visible as a brief pause with a “Saving…” dialog) before closing BGB or the underlying process, and periodically copy your .sav file to a backup location, especially before testing anything unusual like a ROM hack, a cheat code, or an unfamiliar link cable connection. A five-second file copy is cheap insurance against losing a save built over dozens of hours.

Multiplayer Battles: Emulating Wireless-Free Link Battles

Beyond trading, Gen 1’s link cable also supports direct Pokémon battles between two games, a feature that predates any of the wireless or online battling systems introduced in later generations. BGB’s link emulation supports this the same way it supports trades — connect two instances through the Emulator menu’s link cable option, then use the same in-game Pokémon Center connection process you’d use for a trade, choosing battle instead when prompted.

This is a genuinely different experience from a modern online battle simulator: Gen 1’s battle system has quirks later generations patched out, like the original stat-swapping ambiguity around critical hits and certain move-priority interactions, that only show up in an authentic link battle rather than a simulated one. If you’re studying competitive Gen 1 specifically, BGB’s link battles are the closest thing to the original tournament-legal experience available on modern hardware.

BGB vs Other Gen 1 Emulation Options

BGB isn’t the only way to play Gen 1 Pokémon on PC, so here’s how it compares to the other tools you’ll see recommended in emulation communities.

Emulator	Platforms	Best For	2026 Status
BGB 1.6.6	Windows native, Linux/macOS via Wine	Debugger, RNG research, hardware-accurate palettes	Actively maintained, last update July 2025
SameBoy	macOS, Windows, Linux, libretro core	Cross-platform play, cleaner modern UI	Actively maintained, macOS-first design
Gambatte / Gambatte-speedrun	Windows, macOS, Linux, libretro core	Leaderboard-legal speedrun recording	The accepted standard for verified Gen 1 runs
RetroArch (Gambatte core)	Windows, macOS, Linux, Android, handhelds	Unified frontend with shader support	Actively maintained core

If you’re building a Game Boy Color-era setup for Gold, Silver, and Crystal specifically, rather than the original Gen 1 trilogy, our SameBoy setup guide covers that generation in the same level of detail. And if RNG research and hardware-accurate debugging aren’t your priority and you just want the broadest cross-platform tool for the whole Game Boy family, our RetroArch setup guide for Pokémon is the better starting point.

Streaming or Recording a BGB Playthrough

Because BGB renders at the Game Boy’s native low resolution, capture software often needs a small amount of extra configuration to avoid a blurry or incorrectly scaled output when streaming or recording. Set BGB’s window scale to a clean integer multiple (2x, 3x, or 4x) under Video options before opening OBS or your capture tool of choice — non-integer scaling introduces visible artifacting on pixel art that a clean multiple avoids entirely.

In OBS specifically, add BGB as a Window Capture source rather than a Display Capture source if you’re only recording the emulator and not your full desktop — this avoids capturing unrelated windows and keeps the output cropped exactly to the game. If you’re using BGB’s debugger alongside a recording for an RNG explainer or a glitch breakdown, a second window capture source pointed at the debugger window lets you show both simultaneously without needing separate recording software for each.

Audio capture works the same way it would for any Windows application — BGB outputs through your system’s default audio device, so no special routing is required unless you’re running a more complex separate-track setup for post-production editing.

Where BGB Fits Into a Full Pokémon Emulation Setup

BGB only covers the original Game Boy generation. If your goal is a complete multi-generation Pokémon library, you’ll need companion tools for later console generations: mGBA or VBA-M for the Game Boy Advance era (Ruby, Sapphire, Emerald, FireRed, LeafGreen), DeSmuME for the Nintendo DS generation, and PKHeX if you want to move or edit save data across all of them. Our best Pokémon emulators guide maps out the right tool for every generation if you’re starting a build from scratch rather than adding Gen 1 to an existing setup.

Building a Complete Kanto Dex: Managing Red, Blue, and Yellow Together

Completing the original 151-entry Pokédex requires more than one version, since Gen 1’s version-exclusive split (and Yellow’s distinct pool, closer to the anime) means no single cartridge contains every species. Running all three versions side by side in BGB is straightforward, but it helps to plan the trading loop before you’re deep into any single playthrough rather than realizing you need a specific exclusive halfway through the postgame.

Version	Notable Exclusives	Trade-Only Evolutions to Plan For
Red	Ekans, Arbok, Oddish line, Mankey line, Growlithe, Scyther, Electabuzz	Kadabra, Machoke, Graveler, Haunter
Blue	Sandshrew, Sandslash, Bellsprout line, Meowth line, Vulpix, Pinsir, Magmar	Kadabra, Machoke, Graveler, Haunter
Yellow	Follows the anime more closely; starter is fixed as Pikachu	Kadabra, Machoke, Graveler, Haunter

A practical approach is running three BGB instances simultaneously toward the late game, using the link cable steps from earlier to shuttle version-exclusive Pokémon and trade-evolution candidates back and forth as each playthrough reaches a Pokémon Center. Because BGB’s link emulation works the same way regardless of which two versions you connect, there’s no extra configuration needed beyond repeating the same host/connect process for each pairing.

Frequently Asked Questions

Is BGB free?
Yes. BGB is freeware with no purchase price, license key, or account requirement.

Does BGB run on Mac or Linux?
Not natively. BGB ships Windows-only builds, but running it through Wine on Linux or macOS is common practice and works well, since Game Boy emulation is light enough that translation-layer overhead isn’t noticeable.

Can I use BGB for speedrun submissions?
Not for leaderboard-verified runs. BGB is widely used for practice and RNG research, but the accepted emulator for verified Gen 1 speedrun submissions is Gambatte-speedrun, a separate, purpose-built core.

Can I trade Pokémon between BGB and another Game Boy emulator?
Link cable protocols vary by emulator implementation, so cross-emulator trading isn’t guaranteed to work reliably. The safest path is trading between two BGB instances running the same version.

Why does Pokémon Yellow show color in BGB but Red and Blue don’t?
Yellow supported limited color when played on Game Boy Color hardware, which BGB can replicate through its GBC-style palette option. Red and Blue were designed only for the original monochrome Game Boy, so they default to greyscale unless you apply an artificial recoloring palette.

What does the “detect GBA” option do?
It changes BGB’s emulated behavior to match a Game Boy Advance running the game in backward-compatibility mode, which affects certain RNG manipulation techniques. Leave it off for a standard playthrough unless you’re specifically researching GBA-compatible RNG manipulations.

Is it legal to use BGB?
The emulator itself is legal software. Legality depends on how you source your ROMs — dumping a cartridge you personally own is broadly considered fair use in many jurisdictions, while downloading ROMs for games you don’t own is copyright infringement in most countries.

Do I need to know how to use a debugger to use BGB?
No. The debugger is entirely optional and aimed at ROM hackers, developers, and RNG researchers. A standard playthrough of Red, Blue, or Yellow never requires opening it.

Can BGB play Pokémon Gold, Silver, or Crystal too?
Yes, technically — BGB supports Game Boy Color titles as well as original Game Boy games, so Gen 2 ROMs will load and run. That said, if Gen 2 specifically is your focus, a dedicated setup like SameBoy is worth considering for its more modern cross-platform support and interface.

Will updating to a newer BGB version break my existing saves?
No. Save files are tied to the ROM and its internal save format, not to the emulator version. You can safely update from an older 1.6.x release to 1.6.6 without losing progress, though it’s still good practice to back up your .sav file before any update as a general precaution.