The Glitchhouse / Data
Gen 1 Glitch Data: Red, Blue and Yellow
Five free data files about the glitches in Pokemon Red, Blue and Yellow: every species index from 0 to 255, the Ditto glitch Special list from 1 to 255, all 21 Glitch Cities of each game, every glitch move with its six bytes and what it did in a test battle, and Glitch Lab's verdicts on nine disputed glitch facts.
Every value comes from the game's own code. My Glitch Lab runs the cartridges in an emulator and plays them with button presses from normal saves, then reads each result from the game's memory. The parts that roll no random numbers were repeated in a second emulator. None of it ran on a real Game Boy.
Download the files as JSON or CSV, build on them, and credit GardenFlouer, gardenflouer.com.
The files
- Every species index 0 to 255
gen1-indexEvery species index 0 to 255 in Red and Blue and in Yellow: name, Pokedex number, kind, glitch flag and where its Pokedex seen-flag write lands. 512 rows.
- The Ditto glitch Special list
ditto-specialSpecial 1 to 255 after a trainer escape: the wild Pokemon or trainer you meet, and whether the game battles, freezes or changes the sixth item. 510 rows.
- All 21 Glitch Cities per game
glitch-cityThe 21 Glitch City variants of each game: arrival point, view pointer, size and how much of each you can walk. 42 rows.
- Glitch Lab's nine verdicts
proofsOne row per questioned glitch fact: verdict, games, how it was tested and the evidence. 9 rows.
- Every glitch move, tested
glitch-moves0x00 and 0xA6 to 0xFF in Red, in Blue and in Yellow: the six bytes, what each move does, and what crashed, froze or locked up in a test battle. 273 rows.
Each JSON file opens with a header that explains every column, the method, the version and how to credit it, then lists the rows. Each CSV file holds the same rows, with the column names on its first line, in UTF-8. Red and Blue share the rows marked red-blue, because Glitch Lab measured the same values in both; the glitch move file has rows for red, blue and yellow.
Key facts from the files
Each of these comes straight from the rows below, and the script that writes the files checks them.
- Red and Blue have 39 MissingNo. indices and Yellow has 39. The game gives every one of them Pokedex number 0.
- In Red and Blue, 40 species indices set the top bit of the sixth bag item's count when a battle loads them: 'M (index 0) and the 39 MissingNo. A count of 5 becomes 133, and a count of 128 or more stays the same.
- In Yellow, index 0 has Pokedex number 176, so it leaves the sixth item alone. The 39 MissingNo. set its top bit, and so would glitch indices 200 and 249, which also have Pokedex number 0 (worked out from the code, not played).
- In the Ditto glitch, a Special of 21 gives a level 7 Mew in Red, Blue and Yellow.
- Of the 255 Special values, 251 start a normal battle in Red and Blue and 217 in Yellow, plus 36 in Yellow that battle or freeze depending on the save.
- In Yellow, Special 182, 183 and 184 always give a MissingNo. battle you can leave. The other 36 MissingNo. values set the sixth item's top bit and then battle or freeze depending on bytes in the cartridge's save memory; in most saves tested they battled or froze together.
- Each game has 21 Glitch City variants. The largest spans 234 by 236 coordinates, and the roomiest to walk is Route 17 with 146 reachable coordinates. In 14 of Red and Blue's 21 you cannot take a single step.
- The old man glitch does not work on Route 21: Glitch Lab proved that claim false by play.
- Red, Blue and Yellow have 91 glitch moves each, 0x00 and 0xA6 to 0xFF. The 30 from 0xA6 to 0xC3 are the Super Glitches, whose names are read from memory; 0xC4 to 0xFF are named HM01 to HM05 and TM01 to TM55. Yellow's bytes differ from Red and Blue's on 33 of them.
- Opening FIGHT with 0xA6, whose six bytes are Bulbasaur's Pokedex number and base stats, crashed Red, Blue and Yellow. 23 glitch moves have 0 PP in every game, and 0xFF (TM55) never runs: the game reads $FF as "cannot move".
Check a number
Type a number from 0 to 255. You get it as a species index in Red and Blue and in Yellow, and as a Special stat in the Ditto glitch, read from the same files you can download.
The answer shows here. Try 21: as a species index it is Mew, and as a Special it gives a level 7 Mew.
Every species index, 0 to 255
The game numbers its Pokemon by a species index from 0 to 255, separate from the Pokedex number. In each game 151 indices are real Pokemon. The other 105 are glitches: index 0, the 39 MissingNo. with Pokedex number 0, and 65 more from index 191 up.
When a battle loads a Pokemon, the game marks it as seen in the Pokedex by setting flag "Pokedex number minus 1" in a 19-byte list. A Pokedex number of 0 wraps to flag 255, which lands on bit 7 of the sixth bag item's count. That is the MissingNo. item duplication, and the sixth_item_top_bit column marks every index that does it. The MissingNo. page shows it step by step.
How it was measured. The Pokedex numbers come from running the game's IndexToPokedex routine for each index in the PyBoy emulator (EMU-TRUTH, 2026-09-28), checked against Glitch Lab's battle runs for indices 1 to 199. The seen-flag write follows from the Pokedex number by the game's own rule; for indices 1 to 199 and for 'M the game's own write was also read in those runs, and the seen_flag_basis column says which.
| Index | Red and Blue | Yellow |
|---|---|---|
00 0 | 'M (00) No. 0 sixth item top bit | 3TRAINERPOKé₽ (00) No. 176 |
01 1 | Rhydon No. 112 | Rhydon No. 112 |
15 21 | Mew No. 151 | Mew No. 151 |
1F 31 | MissingNo. No. 0 sixth item top bit | MissingNo. No. 0 sixth item top bit |
54 84 | Pikachu No. 25 | Pikachu No. 25 |
83 131 | Mewtwo No. 150 | Mewtwo No. 150 |
B6 182 | MissingNo. (Fossil Kabutops form) No. 0 sixth item top bit | MissingNo. No. 0 sixth item top bit |
BF 191 | ▶ A No. 250 | 4<BOLD_A>もぺ4<BOLD_H>もへ┘ぺ No. 250 |
C4 196 | PokeWTrainer No. 205 | Xやゥ-は×ゥ,はの No. 203 |
FF 255 | 'M (FF) No. 6 | Q (FF) No. 121 |
The 12 columns
game- red-blue (Pokemon Red and Blue, which give the same values) or yellow (Pokemon Yellow)
index- the species index the game uses internally, 0 to 255 (not the Pokedex number)
hex- the same index in hexadecimal, 00 to FF
name- the name as gardenflouer.com writes it; empty where no source names it
name_source- game (the game's own name, written as this site writes it), glitchhouse (the name its Glitchhouse page gives it), glitch city wiki (the community name), pret charmap (the name bytes read through pret's charmap: the English game draws other tiles for the kana), or empty
dex- the Pokedex number the game's IndexToPokedex routine returns for this index
kind- species (a real Pokemon), missingno (Pokedex number 0, index 1 to 190) or glitch (index 0, 191 to 255)
glitch- true for every index that is not a real Pokemon
seen_flag_write- the bit the Pokedex seen-flag write sets when a battle loads this index (LoadEnemyMonData marks Pokedex number minus 1 in a 19-byte list, so 0 and numbers past 152 land in the bag)
sixth_item_top_bit- true when that write sets bit 7 of the sixth bag item's count: a count of 5 becomes 133, 128 or more stays the same
seen_flag_basis- watched in the game (the game's own write was read in Glitch Lab's runs, in every game of the row) or worked out from the code (from the Pokedex number by the same rule)
page- the Glitchhouse page about this index, if there is one
Download gen1-index.json or gen1-index.csv.
The Ditto glitch Special list, 1 to 255
After a trainer escape, the battle waiting on the route you fled from uses the low byte of the last enemy's Special stat. A wild Ditto that transforms into your Pokemon copies your Pokemon's Special. A Special of 1 to 199 then gives the wild Pokemon with that species index at level 7. A Special of 200 to 255 gives trainer class Special minus 200, with party 7.
The steps are on the Ditto glitch page and in the Mew glitch guide.
How it was measured. Every value was run through the game's own battle start in the PyBoy emulator from a real escape state (two RAM bytes, $CD2D and $CD2E, set to the value), and 15 values per game were played through by button presses with a real wild Ditto. On 2026-11-14 every value was run again with no debugging hooks in the emulator (a hook changes a byte of the cartridge as the game reads it, and Yellow's MissingNo. read their picture from such bytes); Yellow's 36 MissingNo. were run in several saves.
| Special | Red and Blue | Yellow |
|---|---|---|
| 1 | Rhydon L7, battle played | Rhydon L7, battle |
| 21 | Mew L7, battle played | Mew L7, battle played |
| 31 | MissingNo. L7, battle, sixth item 5 becomes 133 played | MissingNo. L7, depends on the save, sixth item 5 becomes 133 played |
| 76 | Ditto L7, battle played | Ditto L7, battle played |
| 150 | Pidgeotto L7, battle played | Pidgeotto L7, battle played |
| 181 | MissingNo. L7, battle, sixth item 5 becomes 133 | MissingNo. L7, depends on the save, sixth item 5 becomes 133 |
| 182 | MissingNo. (Fossil Kabutops form) L7, battle, sixth item 5 becomes 133 played | MissingNo. L7, battle, sixth item 5 becomes 133 played |
| 183 | MissingNo. (Fossil Aerodactyl form) L7, battle, sixth item 5 becomes 133 | MissingNo. L7, battle, sixth item 5 becomes 133 played |
| 184 | MissingNo. (Ghost form) L7, battle, sixth item 5 becomes 133 | MissingNo. L7, battle, sixth item 5 becomes 133 played |
| 191 | ▶ A L7, battle, sixth item 5 becomes 7 played | 4<BOLD_A>もぺ4<BOLD_H>もへ┘ぺ L7, freeze, sixth item 5 becomes 7 played |
| 193 | ゥ L7, freeze | ね<$04>のぼゴ♀<$21>.に<$01> L7, freeze |
| 196 | PokeWTrainer L7, freeze | Xやゥ-は×ゥ,はの L7, battle |
| 200 | glitch class 0 ('M (FF) L4; Drowzee L4), battle played | glitch class 0 (no Pokemon), battle played |
| 201 | YOUNGSTER (Ekans L14; Sandshrew L14), battle played | YOUNGSTER (Ekans L14; Sandshrew L14), battle played |
| 230 | ROCKET (Raticate L20; Zubat L20), battle played | ROCKET (Raticate L20; Zubat L20), battle played |
| 246 | AGATHA (MissingNo. L205; Seel L205; Pikachu L205; Seadra L205; Growlithe L205; - - L205), battle, sixth item 5 becomes 133 | AGATHA (Dodrio L205; Seel L205; Pikachu L205; Seadra L205; Growlithe L205; index E5 L205), battle |
| 251 | glitch class 51 (Glitch L0; Omastar L0; M p'u ゥ L0; Nidorino L0; Chansey L0; Clefairy L0), | glitch class 51 (Cubone L9; MissingNo. L9; <$02>ゥ(や<$21>Zやひに4 L9; Voltorb L9; Rhyhorn L9; Gengar L9), battle |
| 255 | glitch class 55 (no Pokemon), battle, sixth item 5 becomes 133 played | glitch class 55 (no Pokemon), battle played |
The 14 columns
game- red-blue (Pokemon Red and Blue, which give the same list) or yellow
special- the low byte of the Special stat the wild Ditto copied (a Special of 257 counts as 1), 1 to 255
kind- wild (Special 1 to 199: a wild Pokemon of that species index) or trainer (200 to 255: trainer class Special minus 200, party 7)
species_index- for wild: the species index met, equal to the Special
name- for wild: the species name as gardenflouer.com writes it (see gen1-index), empty where none
level- for wild: the level, 7 (the transformed Ditto's untouched Attack stage)
trainer_class- for trainer: the class number, Special minus 200
trainer_class_name- for trainer: the class name in the game's own text, empty for glitch classes
party_number- for trainer: the party number, 7
party- for trainer: the enemy party the game builds (index, name, level for each Pokemon)
outcome- what the game did when the battle started: battle, freeze, no battle menu, or depends on the save (Yellow's 36 MissingNo. other than 182 to 184: battle or freeze is decided by bytes of the cartridge's save memory; in most saves tested the 36 battled or froze together)
outcome_detail- how it froze or stalled, or for depends on the save what it did in each save tested; empty for a battle
sixth_item- what the battle did to the sixth bag item's count, tested with a count of 5
played- true for the values played through for real with a wild Ditto, by button presses; every value was also run through the game's battle start (the probe)
Download ditto-special.json or ditto-special.csv.
Every Glitch City
When the Safari Game runs out of steps, the game sends you to the gate, and the gate's south door returns you to the last outdoor map. If that map has 4 or fewer warps, the game reads the missing warp from the map's own block data and uses those bytes as your position and screen pointer. That is Glitch City, and each game has 21 maps where it can happen.
How to get in, and a viewer for every one of them, are on the Glitch City page. The maps themselves, all 63 as full-size PNG files with one zip per game, are in the Glitch City map gallery.
How it was measured. Each variant was defined from the cartridge's own map data, loaded into the game from a crafted save in the PyBoy emulator, and walked: in all 63 variants the coordinates the game itself let the player reach were exactly the model's set, with the same exits.
| Map | Arrival x, y | View pointer | Size (x by y) | Reachable: Red and Blue | Reachable: Yellow |
|---|---|---|---|---|---|
| Pallet Town | 82, 80 | $0B4F | 234 by 236 | 1 | 1 |
| Indigo Plateau | 39, 28 | $1B1A | 234 by 236 | 1 | 1 |
| Route 1 | 49, 10 | $0A0A | 234 by 36 | 10 | 1 |
| Route 3 | 44, 44 | $2C2C | 70 by 236 | 1 | 1 |
| Route 4 | 42, 87 | $572B | 90 by 236 | 1 | 2 |
| Route 6 | 10, 116 | $7474 | 20 by 218 | 99 the west edge loads map $FF and the game crashes | 99 |
| Route 9 | 87, 43 | $2A57 | 194 by 236 | 1 | 11 |
| Route 10 | 87, 87 | $5757 | 234 by 182 | 1 | 1 |
| Route 12 | 41, 44 | $2C2C | 234 by 108 | 9 | 6 |
| Route 13 | 15, 15 | $1C31 | 60 by 18 | 1 | 1 |
| Route 14 | 119, 119 | $7777 | 234 by 200 | 42 | 43 |
| Route 15 | 10, 10 | $0A0A | 60 by 18 | 13 | 2 |
| Route 17 | 67, 67 | $654E | 234 by 144 | 146 | 146 |
| Route 18 | 49, 100 | $4318 | 50 by 236 | 1 | 1 |
| Route 19 | 37, 87 (Yellow: 26, 26) | $241B (Yellow: $1A29) | 234 by 200 (Yellow: 234 by 54) | 1 | 1 |
| Route 20 | 107, 107 | $6B6B | 154 by 236 | 111 walking west to x 100 fires the east edge and loads Route 19 at y 144 and below, past its last row | 83 |
| Route 21 | 10, 10 | $4E74 | 20 by 90 | 1 | 1 |
| Route 22 | 87, 43 | $2C2C | 214 by 236 | 1 | 29 |
| Route 23 | 54, 54 | $1735 | 234 by 144 | 1 | 1 |
| Route 24 | 87, 87 | $5757 | 234 by 218 | 1 | 1 |
| Route 25 | 87, 87 | $5757 | 194 by 236 | 1 | 5 |
The 20 columns
game- red-blue or yellow
map- the outdoor map the gate exit leads back to (pret's map constant)
map_name- the same map in words
warps- how many warps the map has (4 or fewer, so the gate's warp 5 is read past the end of its list)
misread_from- pret's label for the 4 bytes read in place of the missing warp: the map's own block data
arrival_x- the X coordinate you arrive at
arrival_y- the Y coordinate you arrive at
view_pointer- the screen pointer the misread bytes set, in hexadecimal: where the game reads the blocks it draws
view_region- where that pointer points: ROM0 (the home bank) or ROMX (a switchable bank)
x_min- the smallest X you can stand on before the map edge loads another map
x_max- the largest such X
y_min- the smallest such Y
y_max- the largest such Y
width- the number of X coordinates in that box
height- the number of Y coordinates in that box
screen_blocks_wide- how many blocks wide everything you could ever see from inside the box is
screen_blocks_high- how many blocks high it is
reachable- how many coordinates you can walk to from the arrival point (1 means you cannot move)
exit- what happens if you walk out through an edge, empty when no edge can be reached
flood_matches- true when walking every reachable coordinate in the game itself gave exactly this set and these exits
Download glitch-city.json or glitch-city.csv.
Glitch Lab's nine verdicts
Glitch Lab settled nine questions by playing the game: eight facts about these glitches that were in doubt, on this site or elsewhere, and a check of its own second emulator. One claim was false: the old man glitch does not work on Route 21.
How it was measured. Each fact was settled by playing the game with button presses from normal saves in the PyBoy emulator, with every decision read from RAM or from the game reaching a named routine. The parts that roll no random numbers were repeated in a second emulator, gambatte, in lock step.
Glitch City by NO, save, reset, in Red, Blue and Yellow
proven true in Red, Blue, Yellow
The byte that arms it, wNextSafariZoneGateScript ($CF0D), is not saved, so after the reset the worker greets you and the Safari Game keeps counting outside. Paying sets 502 steps. Leaving the gate after time-up on Route 20 lands at x 107, y 107, view pointer $6B6B. More on the Glitch City page.
Tested: Played by button presses from a normal save in PyBoy: pay, answer NO, save inside the Safari Zone, reset, walk out, run the steps out. Second emulator: gambatte held the same RAM from paying to walking out of the gate.
MissingNo sets the top bit of the sixth item's count
proven true in Red, Blue
The sixth item's count went from 5 to 133 at the first MissingNo. or 'M battle. Counts of 130 and 200 stayed the same: a bit is set, 128 is not added. More on the MissingNo. page.
Tested: A new game from power-on with a typed name, then the old man, Fly to Cinnabar Island and Surf up the Route 20 shore column, all by button presses in PyBoy. Second emulator: gambatte agreed on the new game and the naming; the encounters are random, so PyBoy only.
MissingNo's Pokedex number is 0, so its seen flag lands on the sixth item
proven true in Red, Blue, Yellow
IndexToPokedex returned 0; 0 minus 1 wraps to 255; flag 255 of wPokedexSeen ($D30A) is bit 7 of $D329, the sixth item's count. Yellow's is one byte lower. More on the MissingNo. page.
Tested: A hook on the game's FlagAction routine in the same battles, reading the registers and the byte it wrote. Second emulator: PyBoy only.
Item duplication in Yellow by another route
proven true in Yellow
With Special 182, 183 or 184 a level 7 MISSINGNO. sets the sixth count from 5 to 133, and you can run and save. Yellow's other 36 MissingNo. set the bit too, and then battle or freeze depending on bytes of the cartridge's save memory: their picture, read from address $0006, overwrites the byte that tells the sound code where its music is, and the cry jumps to whatever that byte points at. The old runs that froze every time had debugging hooks inside those picture bytes. More on the Ditto glitch page.
Tested: The trainer escape, a wild Ditto that copies a Special of 182, then Route 8 and a save, by button presses in PyBoy; every other MissingNo. value run through the same battle start, again on 2026-11-14 with no debugging hooks, in several saves and with every value of the sound byte their picture overwrites. Second emulator: PyBoy only.
Mew glitch: where it fires, the Youngster lock, Mew at level 7
proven true in Red, Blue, Yellow
The waiting battle is Route 8's own script (wRoute8CurScript 1), so it fires only back on Route 8, where the START menu opens by itself. B closes it and a level 7 Mew appears ($CD2D 21, $CD2E 7). Standing next to the Youngster or talking to him locks the game. More on the Mew glitch guide.
Tested: Played by button presses in PyBoy, including standing next to the Youngster and talking to him. Second emulator: gambatte agreed through the escape and the landing in Cerulean City; the battles are PyBoy only.
Old man glitch on Route 21
proven false in Red, Blue
Entering Route 21 loads its own grass list over the name. All 12 encounters were Route 21's grass Pokemon, such as Tangela and Raticate, never the name. More on the old man glitch page.
Tested: After the old man, Surf onto Route 21 and six encounters per game on its shore column, by button presses in PyBoy. Second emulator: PyBoy only.
The tail of a typed name
settled in Red, Blue, Yellow
After a typed name the bytes are 0x00, so old man slots 4 and 5 are always 'M. Letters erased with B leave 0x50 (MissingNo. index 80). Preset names such as RED copy the next names in the list instead. More on the old man glitch page.
Tested: A real new game from power-on with empty save memory, the naming screen driven by the D-pad and A. Second emulator: gambatte agreed on the whole run.
Ditto glitch Special list 1 to 255
computed and confirmed in Red, Blue, Yellow
Below 200, Special S gives species S at level 7, and 21 is Mew. From 200 it gives trainer class S minus 200 with party 7. All 45 played runs matched the probe. More on the Ditto glitch page.
Tested: Every value from 1 to 255 run through the game's battle start from a real escape state, with two RAM bytes ($CD2D, $CD2E) set, and 15 values per game played through with a real Ditto. Second emulator: PyBoy only (the Ditto battles depend on random numbers).
Second emulator (gambatte)
agrees where comparable in Red, Blue, Yellow
The same game byte for byte, apart from the play-time counter, wherever the game rolls no random numbers. Random rolls differ because the two emulators start the divider register at different phases.
Tested: gambatte, built from source and run in lock step with PyBoy on the same button presses, with RAM compared at every stage. Second emulator: this is the second emulator.
The 9 columns
fact- the fact's number in Glitch Lab's proof notes (research/glitchlab/PROOFS.md)
title- the fact as it was questioned
verdict- proven true, proven false, settled, computed and confirmed, or agrees where comparable
verdict_text- the verdict exactly as the proof notes state it
games- the games it was tested in
method- how it was tested
second_emulator- what the second emulator (gambatte) confirmed; PyBoy only means one emulator
evidence- the short form of the evidence
page- the gardenflouer.com page that covers it
Download proofs.json or proofs.csv.
Every glitch move, tested
All 91 glitch moves of each game, 0x00 and 0xA6 to 0xFF, with the six bytes the game loads for them and what happened when I opened FIGHT, used them, let a foe use them and looked at the status screen, in one test battle per game. 0xA6 to 0xC3 are the Super Glitches, whose names are read from memory. The page Super Glitch and every glitch move explains every column with a sortable table; here are a few rows.
How it was measured. Every move was run in each game's own code in the PyBoy emulator, from one crafted battle (a level 50 Lapras against a wild level 50 Snorlax), by button presses, five ways: the player using it, the same with its name kept to 20 bytes, the foe using it both ways, and the status screen. Every run was replayed in a second, hook-free PyBoy and counted only when both ended with the same memory; all 448 completed runs per game agreed. Only the FIGHT menu names were also run in the gambatte emulator, which disagreed with PyBoy on most Super Glitch names. Hits, misses and damage are one sample each.
| Move | Red | Blue | Yellow |
|---|---|---|---|
00 0 | 90 $74 102 $7A 80 13 The empty move: with it first, FIGHT shows only dashes, yet A picks it. Then: damage, then a jump past the effect table into other code. the foe using it: freeze; the foe using it, name kept short: freeze | 90 $74 102 $7A 80 13 The empty move: with it first, FIGHT shows only dashes, yet A picks it. Then: damage, then a jump past the effect table into other code. the foe using it: freeze; the foe using it, name kept short: freeze | 90 $74 102 $31 81 10 The empty move: with it first, FIGHT shows only dashes, yet A picks it. Then: damage, then a jump past the effect table into echo RAM. the foe using it: freeze; the foe using it, name kept short: freeze |
A6 166 | 1 $2D 49 $31 45 65 Acts as Jump Kick, the effect of Jump Kick and Hi Jump Kick. opening FIGHT: crash; the foe using it: crash | 1 $2D 49 $31 45 65 Acts as Jump Kick, the effect of Jump Kick and Hi Jump Kick. opening FIGHT: crash; the foe using it: crash | 1 $2D 49 $31 45 65 Acts as Jump Kick, the effect of Jump Kick and Hi Jump Kick. opening FIGHT: crash; the foe using it: softlock |
A7 167 | 22 $03 45 $40 85 0 Acts as drain HP, the effect of Absorb, Mega Drain and Leech Life. nothing crashed | 22 $03 45 $40 85 0 Acts as drain HP, the effect of Absorb, Mega Drain and Leech Life. nothing crashed | 22 $03 45 $40 85 0 Acts as drain HP, the effect of Absorb, Mega Drain and Leech Life. nothing crashed |
A8 168 | 64 $E5 64 $21 45 0 Damage, then a jump past the effect table into other code. opening FIGHT: crash; the foe using it: crash | 64 $E5 64 $21 45 0 Damage, then a jump past the effect table into other code. opening FIGHT: crash; the foe using it: crash; using it, name kept short: cpu lock-up; the foe using it, name kept short: cpu lock-up | 64 $E4 64 $21 45 0 Damage, then a jump past the effect table into other code. opening FIGHT: crash; the foe using it: softlock |
C1 193 | 79 $CE 227 $08 38 0 Damage, then unused effect $4E's code runs with the wrong byte ($CE): that table entry is empty, so the game jumps to address $0000. opening FIGHT: crash | 79 $CE 227 $08 38 0 Damage, then unused effect $4E's code runs with the wrong byte ($CE): that table entry is empty, so the game jumps to address $0000. opening FIGHT: crash | 79 $CE 227 $08 46 0 Damage, then unused effect $4E's code runs with the wrong byte ($CE): that table entry is empty, so the game jumps to address $0000. nothing crashed |
CE 206 TM06 | 39 $91 55 $03 177 127 Damage, then Swift's code runs with the wrong byte ($91): that table entry is empty, so the game jumps to address $0000. using it: crash; the foe using it: crash; using it, name kept short: crash; the foe using it, name kept short: crash | 39 $91 55 $03 177 127 Damage, then Swift's code runs with the wrong byte ($91): that table entry is empty, so the game jumps to address $0000. using it: crash; the foe using it: crash; using it, name kept short: crash; the foe using it, name kept short: crash | 39 $91 55 $03 177 127 Damage, then Swift's code runs with the wrong byte ($91): that table entry is empty, so the game jumps to address $0000. using it: crash; the foe using it: crash; using it, name kept short: crash; the foe using it, name kept short: crash |
D7 215 TM15 | 75 $6A 0 $00 0 0 Damage, then a jump past the effect table to $A778, inside cartridge RAM (the save data), and runs it as code. the foe using it: crash; using it, name kept short: crash; the foe using it, name kept short: crash | 75 $6A 0 $00 0 0 Damage, then a jump past the effect table to $A778, inside cartridge RAM (the save data), and runs it as code. the foe using it: crash; using it, name kept short: crash; the foe using it, name kept short: crash | 76 $6A 0 $00 0 0 Damage, then a jump past the effect table to $A778, inside cartridge RAM (the save data), and runs it as code. the foe using it: crash; using it, name kept short: crash; the foe using it, name kept short: crash |
EB 235 TM35 | 24 $C0 195 $08 6 0 Damage, then Light Screen's code runs with the wrong byte ($C0). nothing crashed | 24 $C0 195 $08 6 0 Damage, then Light Screen's code runs with the wrong byte ($C0). nothing crashed | 24 $C0 195 $08 6 0 Damage, then Light Screen's code runs with the wrong byte ($C0). nothing crashed |
F7 247 TM47 | 119 $C2 121 $79 123 16 Damage, then poison's code runs with the wrong byte ($C2). nothing crashed | 119 $C2 121 $79 123 16 Damage, then poison's code runs with the wrong byte ($C2). nothing crashed | 119 $92 120 $D1 122 16 Damage, then Attack down 1's code runs with the wrong byte ($92): the stat code reads past its stat table. nothing crashed |
F8 248 TM48 | 28 $62 0 $03 42 67 Damage, then a jump past the effect table into other code (read from the ROM at its address: no run of it came back, so the game was never seen loading it). no run came back | 28 $62 0 $03 42 67 Damage, then a jump past the effect table into other code (read from the ROM at its address: no run of it came back, so the game was never seen loading it). no run came back | 28 $62 0 $03 42 67 Damage, then a jump past the effect table into other code. nothing crashed |
FF 255 TM55 | 81 $3C 97 $32 0 0 Never runs: the game reads move $FF as "cannot move" and skips the turn. nothing crashed | 81 $3C 97 $32 0 0 Never runs: the game reads move $FF as "cannot move" and skips the turn. nothing crashed | 81 $3C 97 $32 0 0 Never runs: the game reads move $FF as "cannot move" and skips the turn. nothing crashed |
The 31 columns
game- red, blue or yellow. Red and Blue hold the same bytes, but their test battles rolled different random numbers, so each game has its own rows
move- the move number, 0 or 166 to 255 (1 to 165 are the real moves)
hex- the same number in hexadecimal, 00 or A6 to FF
group- super glitch (A6 to C3: the name is read past the end of the name list, from memory), tm hm name (C4 to FF: GetName names them HM01 to HM05 and TM01 to TM55) or empty (00, the empty move slot)
name- the name the game prints, for the TM and HM named moves; empty for the others, whose names depend on memory and timing
animation- data byte 1, the animation the move plays
effect- data byte 2, the effect byte
power- data byte 3, the power
type- data byte 4, the type byte
accuracy- data byte 5, out of 256: a random byte below it hits
pp_byte- data byte 6: PP in the low 6 bits, PP Ups in the top 2
pp- the PP the move is learned with
pp_ups- the PP Ups in the PP byte
player_can_pick- false for a move with 0 PP: the player can never pick it (a foe ignores PP)
type_name- the type when the type byte is one of the game's types; empty when it matches none, which makes the move neutral against everything
damage_class- physical (type byte below $14) or special
bytes_from- where the six bytes come from: the move table ends at move 165 and the base data of Pokedex No. 1 to 20 follows it, 28 bytes each
effect_kind- real (an effect from $01 to $56), top bit dropped ($81 to $D6: damage, then the code of the effect byte minus $80 runs with the wrong byte), past the table (damage, then a jump into code that is not a move effect), none (effect $00), turn skipped (move FF: $FF means cannot move) or empty move (00)
effect_name- pret's name for the effect, or for the effect whose code runs when the top bit is dropped
what_it_does- the move with its name kept to 20 bytes, in words
opening_fight- what opening FIGHT with the move first in the list did in the test battle: ok, crash, freeze, cpu lock-up, or unknown (a lock-up leaves no record of where it happened)
player_use- what picking and using it did: ok, crash, freeze, cpu lock-up, 0 pp (the game refuses it) or not reached (the run ended at the FIGHT menu)
foe_use- what the wild Snorlax using it as its only move did: ok, crash, freeze, cpu lock-up or softlock
player_use_name_kept_short- the player's run again with the byte after the 20-byte name buffer set to the end marker before every name lookup, so the effect shows on its own (a 0 PP move was given 10 PP for it)
foe_use_name_kept_short- the foe's run with the name kept to 20 bytes
status_screen- what showing the move on the status screen (page 2) did: ok or softlock
fight_menu_name_length- how many bytes the FIGHT menu's copy of the name wrote in the test battle, in PyBoy (a Super Glitch's name changes with memory and timing); empty when the run stopped first
fight_menu_past_list- how many of those bytes went past the move list's 56 bytes
names_agree_in_gambatte- for a Super Glitch: true when the gambatte emulator, run in lock step, loaded the same 20 name bytes as PyBoy; empty when not compared
learned_by- the glitch Pokemon (by index) that know the move at level 1 or learn it at a level from 2 to 100
complete- false when no run of the move came back (0xF8 in Red and Blue locked PyBoy up every time): its bytes are then read from the ROM at the move's address, not seen loaded by the game
Download glitch-moves.json or glitch-moves.csv.
How it was measured
The cartridges
Glitch Lab plays dumps of my own Red, Blue and Yellow cartridges. Each is an exact match, by SHA-1 checksum, for the game the pret disassembly projects build, so every address and routine name here is theirs.
Glitch Lab
Glitch Lab builds a model of each game's world from the cartridge, writes normal saves (a party, items, badges, a position, no glitch state), and then plays: the D-pad, A, B, START and SELECT, and the reset combo. Every decision is read from the game's memory or from the game reaching one of its own routines. No screenshot decided anything.
Two emulators
The play runs in the PyBoy emulator. A second emulator, gambatte, built from source, ran the same button presses frame by frame beside it. Wherever the game rolls no random numbers, the two held the same memory byte for byte, apart from the play-time counter. Where the game does roll them (wild encounters, battles, the old man's walk), the two parted, so those results rest on PyBoy alone: which wild Pokemon appear, the Ditto battles, and the Youngster and Mew battles of the Mew glitch.
The Ditto list probe
For the Ditto list, every value from 1 to 255 was run through the game's own battle start from a real escape state, with the two memory bytes the glitch uses ($CD2D and $CD2E) set to the value. That tests the game's code without playing each value. Fifteen values per game were also played through for real with a wild Ditto, and all 45 matched.
The glitch move battles
For the glitch moves, a save I wrote starts a wild battle between a level 50 Lapras and a level 50 Snorlax, and each move is tested from that moment: the player using it, the same with its name kept to 20 bytes so that only the effect shows, the Snorlax using it both ways, and the status screen. Every run was replayed in a second copy of PyBoy and counted only when both ended with the same memory. The FIGHT menu names were also run in gambatte, which disagreed with PyBoy on most Super Glitch names, so their lengths in the file are one emulator's sample.
EMU-TRUTH
The Pokedex numbers come from EMU-TRUTH, the check every Glitchhouse page passes before it goes live: it runs the game's own lookup routines in PyBoy for every index (September 2026).
Not on a real Game Boy
None of these files was measured on a real Game Boy. The emulators run the cartridge's own code, but they are emulators, and these pages say so.
Yellow on both hardware paths
Yellow checks at power-on whether it is on a Game Boy or a Game Boy Color and runs extra color code on the Color. Every Yellow value in these files was re-run both ways in November 2026, and the committed values are the Game Boy run. Everything these files state came out the same on both paths; what does differ between them is only the sampled junk that the Super Glitch name walks and misread map headers read out of memory the game never wrote, and the pages that show such samples say so.
How to cite
If you use these numbers, please credit GardenFlouer and link gardenflouer.com.
GardenFlouer. Gen 1 glitch data: Pokemon Red, Blue and Yellow, version 2026-10-31. https://gardenflouer.com/glitchhouse/data
In a sentence: "according to GardenFlouer's Glitch Lab tests (gardenflouer.com/glitchhouse/data)".
On a web page, as a link: <a href="https://gardenflouer.com/glitchhouse/data">GardenFlouer, Gen 1 glitch data</a>
Pokemon and all related names are trademarks of Nintendo, Creatures Inc. and GAME FREAK inc. This site is not affiliated with Nintendo in any way. The files hold measured values, not data copied out of the games.
Questions
Where do these numbers come from?
From the game's own code. Glitch Lab runs the cartridges of Pokemon Red, Blue and Yellow in the PyBoy emulator, plays them with button presses from normal saves, and reads every result from the game's memory. The parts that roll no random numbers were repeated in a second emulator, gambatte.
Were they tested on a real Game Boy?
No. Everything ran in emulators that run the cartridge's own code. Results that depend on random numbers, such as which wild Pokemon appears and the Ditto battles, rest on one emulator, PyBoy.
Can I use the files?
Yes, to read and to quote. If you use the numbers, please credit GardenFlouer and link gardenflouer.com.
Why do Red and Blue share one set of rows?
Glitch Lab measured the same values in Red and in Blue for every column of the first four files, so they share the rows marked red-blue, and the script that writes the files refuses to run if any of those values ever differs. The glitch move file is the exception: Red and Blue hold the same bytes, but a few moves crashed or locked up in one game's test battle and not the other's, so it has rows for each game.
Why do some glitch indices have no name?
A glitch index's name is whatever bytes follow the end of the game's name table, and the English game draws them as tiles no text encoding spells faithfully. The files give a name only where a Glitchhouse page, the game itself or a community source names it, and say which.
Read next
- The Glitchhouse: every glitch Pokemon of Red and Blue, with stats, sprites and cries.
- Glitch City: how to get in, and all 21 of each game.
- Glitch City maps: all 63 maps, full size, to view and download.
- MissingNo.: the sprites, the sixth item, and whether it is safe.
- The Ditto glitch: every Special from 1 to 255, and the steps.
- Super Glitch: every glitch move, what it does and which ones crash.
- The Mew glitch: the trainer escape, step by step.
- The old man glitch: your name as wild Pokemon.
- The name glitch calculator: type a name and see what it summons.