The Glitchhouse / Data

Open data · Free to use with credit

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

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.

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.

IndexRed and BlueYellow
00 0'M (00) No. 0 sixth item top bit3TRAINERPOKé₽ (00) No. 176
01 1Rhydon No. 112Rhydon No. 112
15 21Mew No. 151Mew No. 151
1F 31MissingNo. No. 0 sixth item top bitMissingNo. No. 0 sixth item top bit
54 84Pikachu No. 25Pikachu No. 25
83 131Mewtwo No. 150Mewtwo No. 150
B6 182MissingNo. (Fossil Kabutops form) No. 0 sixth item top bitMissingNo. No. 0 sixth item top bit
BF 191▶ A No. 2504<BOLD_A>もぺ4<BOLD_H>もへ┘ぺ No. 250
C4 196PokeWTrainer No. 205Xやゥ-は×ゥ,はの No. 203
FF 255'M (FF) No. 6Q (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.

SpecialRed and BlueYellow
1Rhydon L7, battle playedRhydon L7, battle
21Mew L7, battle playedMew L7, battle played
31MissingNo. L7, battle, sixth item 5 becomes 133 playedMissingNo. L7, depends on the save, sixth item 5 becomes 133 played
76Ditto L7, battle playedDitto L7, battle played
150Pidgeotto L7, battle playedPidgeotto L7, battle played
181MissingNo. L7, battle, sixth item 5 becomes 133MissingNo. L7, depends on the save, sixth item 5 becomes 133
182MissingNo. (Fossil Kabutops form) L7, battle, sixth item 5 becomes 133 playedMissingNo. L7, battle, sixth item 5 becomes 133 played
183MissingNo. (Fossil Aerodactyl form) L7, battle, sixth item 5 becomes 133MissingNo. L7, battle, sixth item 5 becomes 133 played
184MissingNo. (Ghost form) L7, battle, sixth item 5 becomes 133MissingNo. L7, battle, sixth item 5 becomes 133 played
191▶ A L7, battle, sixth item 5 becomes 7 played4<BOLD_A>もぺ4<BOLD_H>もへ┘ぺ L7, freeze, sixth item 5 becomes 7 played
193ゥ L7, freezeね<$04>のぼゴ♀<$21>.に<$01> L7, freeze
196PokeWTrainer L7, freezeXやゥ-は×ゥ,はの L7, battle
200glitch class 0 ('M (FF) L4; Drowzee L4), battle playedglitch class 0 (no Pokemon), battle played
201YOUNGSTER (Ekans L14; Sandshrew L14), battle playedYOUNGSTER (Ekans L14; Sandshrew L14), battle played
230ROCKET (Raticate L20; Zubat L20), battle playedROCKET (Raticate L20; Zubat L20), battle played
246AGATHA (MissingNo. L205; Seel L205; Pikachu L205; Seadra L205; Growlithe L205; - - L205), battle, sixth item 5 becomes 133AGATHA (Dodrio L205; Seel L205; Pikachu L205; Seadra L205; Growlithe L205; index E5 L205), battle
251glitch class 51 (Glitch L0; Omastar L0; M p'u ゥ L0; Nidorino L0; Chansey L0; Clefairy L0), no battle menuglitch class 51 (Cubone L9; MissingNo. L9; <$02>ゥ(や<$21>Zやひに4 L9; Voltorb L9; Rhyhorn L9; Gengar L9), battle
255glitch class 55 (no Pokemon), battle, sixth item 5 becomes 133 playedglitch 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.

MapArrival x, yView pointerSize (x by y)Reachable: Red and BlueReachable: Yellow
Pallet Town82, 80$0B4F234 by 23611
Indigo Plateau39, 28$1B1A234 by 23611
Route 149, 10$0A0A234 by 36101
Route 344, 44$2C2C70 by 23611
Route 442, 87$572B90 by 23612
Route 610, 116$747420 by 21899
the west edge loads map $FF and the game crashes
99
Route 987, 43$2A57194 by 236111
Route 1087, 87$5757234 by 18211
Route 1241, 44$2C2C234 by 10896
Route 1315, 15$1C3160 by 1811
Route 14119, 119$7777234 by 2004243
Route 1510, 10$0A0A60 by 18132
Route 1767, 67$654E234 by 144146146
Route 1849, 100$431850 by 23611
Route 1937, 87 (Yellow: 26, 26)$241B (Yellow: $1A29)234 by 200 (Yellow: 234 by 54)11
Route 20107, 107$6B6B154 by 236111
walking west to x 100 fires the east edge and loads Route 19 at y 144 and below, past its last row
83
Route 2110, 10$4E7420 by 9011
Route 2287, 43$2C2C214 by 236129
Route 2354, 54$1735234 by 14411
Route 2487, 87$5757234 by 21811
Route 2587, 87$5757194 by 23615
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.

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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.

  7. 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.

  8. 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).

  9. 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.

MoveRedBlueYellow
00 090 $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: freeze90 $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: freeze90 $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 1661 $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: crash1 $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: crash1 $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 16722 $03 45 $40 85 0 Acts as drain HP, the effect of Absorb, Mega Drain and Leech Life. nothing crashed22 $03 45 $40 85 0 Acts as drain HP, the effect of Absorb, Mega Drain and Leech Life. nothing crashed22 $03 45 $40 85 0 Acts as drain HP, the effect of Absorb, Mega Drain and Leech Life. nothing crashed
A8 16864 $E5 64 $21 45 0 Damage, then a jump past the effect table into other code. opening FIGHT: crash; the foe using it: crash64 $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-up64 $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 19379 $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: crash79 $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: crash79 $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 TM0639 $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: crash39 $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: crash39 $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 TM1575 $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: crash75 $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: crash76 $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 TM3524 $C0 195 $08 6 0 Damage, then Light Screen's code runs with the wrong byte ($C0). nothing crashed24 $C0 195 $08 6 0 Damage, then Light Screen's code runs with the wrong byte ($C0). nothing crashed24 $C0 195 $08 6 0 Damage, then Light Screen's code runs with the wrong byte ($C0). nothing crashed
F7 247 TM47119 $C2 121 $79 123 16 Damage, then poison's code runs with the wrong byte ($C2). nothing crashed119 $C2 121 $79 123 16 Damage, then poison's code runs with the wrong byte ($C2). nothing crashed119 $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 TM4828 $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 back28 $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 back28 $62 0 $03 42 67 Damage, then a jump past the effect table into other code. nothing crashed
FF 255 TM5581 $3C 97 $32 0 0 Never runs: the game reads move $FF as "cannot move" and skips the turn. nothing crashed81 $3C 97 $32 0 0 Never runs: the game reads move $FF as "cannot move" and skips the turn. nothing crashed81 $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.