Graphics Overview

The Game Boy outputs graphics to a 160×144 pixel LCD, using a quite complex mechanism to facilitate rendering.

Tiles

Similarly to other retro systems, pixels are not manipulated individually, as this would be expensive CPU-wise. Instead, pixels are grouped in 8×8 squares, called tiles (or sometimes "patterns" or "characters"), often considered as the base unit in Game Boy graphics.

A tile does not encode color information. Instead, a tile assigns a color index to each of its pixels, ranging from 0 to 3. For this reason, Game Boy graphics are also called 2bpp (2 bits per pixel). When a tile is used in the Background or Window, these color indices are associated with a palette. When a tile is used in an object, the indices 1 to 3 are associated with a palette, but ID 0 means transparent.

Palettes

A palette consists of an array of colors, 4 in the Game Boy's case. Palettes are stored differently in monochrome and color versions of the console.

Modifying palettes enables graphical effects such as quickly flashing some graphics (damage, invulnerability, thunderstorm, etc.), fading the screen, "palette swaps", and more.

Layers

The Game Boy has three "layers", from back to front: the Background, the Window, and the Objects.

Background

The background is composed of a tilemap. A tilemap is a large grid of tiles. However, tiles aren't directly written to tilemaps, they merely contain references to the tiles. This makes reusing tiles very cheap, both in CPU time and in required memory space, and it is the main mechanism that helps work around the paltry 8 KiB of video RAM.

The background can be made to scroll as a whole, writing to two hardware registers. This makes scrolling very cheap.

Window

The window is sort of a second background layer on top of the background. It is fairly limited: it has no transparency, it's always a rectangle and only the position of the top-left pixel can be controlled.

Possible usage includes a fixed status bar in an otherwise scrolling game (e.g. Super Mario Land 2).

Objects

The objects layer is designed for elements that need to move independently: objects are made of 1 or 2 stacked tiles (8×8 or 8×16 pixels) and can be displayed anywhere on the screen.

To summarise:

• Tile — an 8×8-pixel chunk of graphics.
• Object — an entry in object attribute memory, composed of 1 or 2 tiles. Can be moved independently of the background.

VRAM Tile Data

Tile data is stored in VRAM in the memory area at $8000–$97FF; with each tile taking 16 bytes, this area defines data for 384 tiles. In CGB Mode, this is doubled (768 tiles) because of the two VRAM banks.

Each tile has 8×8 pixels and a color depth of 2 bits per pixel, allowing each pixel to use one of 4 colors or gray shades.

Tiles are always indexed using an 8-bit integer, but the addressing method may differ:

• The "$8000 method" uses $8000 as its base pointer and uses unsigned addressing, meaning tiles 0–127 are in block 0, and tiles 128–255 are in block 1.
• The "$8800 method" uses $9000 as its base pointer and uses signed addressing, meaning tiles 0–127 are in block 2, and tiles -128 to -1 are in block 1.

Block 1 is shared by both addressing methods. Objects always use "$8000 addressing", but the BG and Window can use either mode, controlled by LCDC bit 4.

Data Format

Each tile occupies 16 bytes, where each line is represented by 2 bytes. For each line, the first byte specifies the least significant bit of the color ID of each pixel, and the second byte specifies the most significant bit. In both bytes, bit 7 represents the leftmost pixel, and bit 0 the rightmost.

For example, the tile data $3C $7E $42 $42 $42 $42 $42 $42 $7E $5E $7E $0A $7C $56 $38 $7C:

Row 0: $3C $7E → 0 2 3 3 3 3 2 0
Row 1: $42 $42 → 0 3 0 0 0 0 3 0
Row 2: $42 $42 → 0 3 0 0 0 0 3 0
Row 3: $42 $42 → 0 3 0 0 0 0 3 0
Row 4: $7E $5E → 0 3 0 1 1 1 1 0
Row 5: $7E $0A → 0 0 1 0 1 0 1 0
Row 6: $7C $56 → 0 3 0 1 0 1 1 0
Row 7: $38 $7C → 0 1 1 1 1 1 0 0

For the first row, $3C $7E are 00111100 and 01111110 in binary. The leftmost bits are 0 and 0, thus color index is 00 = 0. The next bits are 0 and 1, thus color index is 10 = 2 (MSB first!).

VRAM Tile Maps

The Game Boy contains two 32×32 tile maps in VRAM at $9800–$9BFF and $9C00–$9FFF. Any of these maps can be used to display the Background or the Window.

Each tile map contains 1-byte indexes of the tiles to be displayed. Since one tile has 8×8 pixels, each map holds a 256×256 pixel picture. Only 160×144 of those pixels are displayed on the LCD at any given time.

BG Map Attributes (CGB Mode only)

In CGB Mode, an additional map of 32×32 bytes is stored in VRAM Bank 1:

• Priority: 0 = No; 1 = BG/Window color indices 1–3 drawn over OBJ
• Y flip: 0 = Normal; 1 = Vertically mirrored
• X flip: 0 = Normal; 1 = Horizontally mirrored
• Bank: 0 = VRAM bank 0; 1 = VRAM bank 1
• Color palette: Which of BGP0–7 to use

BG-to-OBJ Priority in CGB Mode

Priority between the BG (and window) layer and the OBJ layer is declared in three places: BG Map Attribute bit 7, LCDC bit 0, and OAM Attributes bit 7.

Object Attribute Memory (OAM)

The PPU can display up to 40 movable objects, each 8×8 or 8×16 pixels. Only 10 objects can be displayed per scanline. Object tiles are taken from tile blocks 0 and 1 at $8000–$8FFF with unsigned numbering.

Object attributes reside in OAM at $FE00–$FE9F. Each of the 40 entries consists of 4 bytes:

Byte 0 — Y Position

Y = Object's vertical position on the screen + 16.

• Y=0 hides an object
• Y=16 displays at top of screen
• Y=152 displays 8×8 object at bottom
• Y=160 hides an object

Byte 1 — X Position

X = Object's horizontal position on the screen + 8. An off-screen value (X=0 or X≥168) hides the object, but it still counts towards the 10-objects-per-scanline limit.

Byte 2 — Tile Index

In 8×8 mode, specifies the tile index ($00–$FF) from $8000–$8FFF. In 8×16 mode, the top tile is NN & $FE, the bottom tile is NN | $01.

Byte 3 — Attributes/Flags

• Priority: 0 = No, 1 = BG/Window indices 1–3 drawn over this OBJ
• Y flip: Entire OBJ vertically mirrored
• X flip: Entire OBJ horizontally mirrored
• DMG palette: 0 = OBP0, 1 = OBP1
• Bank (CGB): 0 = VRAM bank 0, 1 = VRAM bank 1
• CGB palette: Which of OBP0–7 to use

Object Priority and Conflicts

Selection priority: During OAM scan, the PPU scans OAM sequentially ($FE00 to $FE9F), selecting up to 10 objects whose Y coordinates overlap the current line.

Drawing priority:

• Non-CGB mode: smaller X coordinate → higher priority. Equal X → earlier in OAM wins.
• CGB mode: only OAM position determines priority (earlier = higher).

OAM DMA Transfer

FF46 — DMA: Writing to this register starts a DMA transfer from ROM or RAM to OAM.

The transfer takes 160 M-cycles: 640 dots (1.4 lines) in normal speed. During OAM DMA on DMG, the CPU can only access HRAM ($FF80–$FFFE).

Best Practice DMA Routine

LCD Control (LCDC — FF40)

LCDC is the main LCD Control register. Its bits toggle what elements are displayed on the screen.

• Bit 7 — LCD & PPU enable: 0=Off, 1=On. ⚠ Stopping LCD outside VBlank may damage hardware!
• Bit 6 — Window tile map area: 0=$9800, 1=$9C00
• Bit 5 — Window enable: 0=Off, 1=On
• Bit 4 — BG & Window tile data area: 0=$8800–$97FF, 1=$8000–$8FFF
• Bit 3 — BG tile map area: 0=$9800, 1=$9C00
• Bit 2 — OBJ size: 0=8×8, 1=8×16
• Bit 1 — OBJ enable: 0=Off, 1=On. Can be toggled mid-frame!
• Bit 0 — BG & Window enable/priority: Non-CGB: disables BG/Window. CGB: controls BG priority.

LCD Status Registers

FF44 — LY: LCD Y coordinate [read-only]

LY indicates the current horizontal line (0–153). Values 144–153 indicate VBlank.

FF45 — LYC: LY compare

When LY == LYC, the "LYC=LY" flag in STAT is set and (if enabled) a STAT interrupt is requested.

FF41 — STAT: LCD status

LCD Position and Scrolling

FF42–FF43 — SCY, SCX: Background viewport position

Specify the top-left coordinates of the visible 160×144 pixel area within the 256×256 BG map. The viewport wraps around.

FF4A–FF4B — WY, WX: Window position

WX=7, WY=0 places the Window at top-left, fully covering the background.

Window Internal Line Counter

The window keeps an internal line counter similar to LY, but it only increments when the window is visible on that scanline. This means hiding the Window mid-frame inhibits the Y-position counter increment.

Palette Registers

FF47 — BGP: BG palette data (Non-CGB)

FF48–FF49 — OBP0, OBP1: OBJ palettes (Non-CGB)

Work like BGP, except the lower two bits are ignored (color index 0 is transparent for OBJs).

CGB Color Palettes

CGB has palette RAM (CRAM) accessed through BCPS/BGPI ($FF68) and BCPD/BGPD ($FF69). Each color is stored as little-endian RGB555:

8 palettes × 4 colors × 2 bytes = 64 bytes of BG palette memory. OBJ palettes (OCPS/OBPI $FF6A, OCPD/OBPD $FF6B) work identically but are separate.

Rendering Overview

The image is drawn by the PPU progressively, directly to the screen. A frame consists of 154 scanlines; during the first 144, the screen is drawn top to bottom, left to right.

A "dot" = one 2²² Hz (≅ 4.194 MHz) time unit. One frame = 70224 dots @ ~59.7 fps.

PPU Modes

Mode 3 Penalties

Mode 3's minimum length is 172 dots (160 pixels + 12 setup dots). Three things cause extra penalties:

• Background scrolling: SCX % 8 dots penalty at beginning
• Window: 6-dot penalty when window starts
• Objects: 6 to 11 dot penalty per object

OBJ Penalty Algorithm

1. Determine the BG/Window tile that the OBJ's leftmost pixel is within
2. If that tile hasn't been considered by a previous OBJ yet: count pixels to the right, subtract 2, incur that many dots (min 0)
3. Incur a flat 6-dot penalty for fetching the OBJ tile

Exception: an OBJ with OAM X=0 always incurs 11-dot penalty regardless of SCX.

Pixel FIFO

There are two pixel FIFOs: one for background pixels and one for object pixels. Each FIFO can hold up to 16 pixels. Each pixel in the FIFO has four properties:

• Color: 0–3
• Palette: CGB: 0–7, DMG: only for objects
• Sprite Priority: CGB: OAM index
• Background Priority: OBJ-to-BG Priority bit

Pixel Fetcher Steps

The fetcher has 5 steps (first four take 2 dots each, fifth attempts every dot):

1. Get Tile — determine which tile to fetch from the tilemap
2. Get Tile Data Low — fetch first bitplane byte
3. Get Tile Data High — fetch second bitplane byte
4. Sleep — do nothing
5. Push — push 8 pixels to the FIFO (only if FIFO is empty)

Pixel Rendering (Mixing)

When both FIFOs have pixels, one pixel is popped from each. If the OAM pixel is not transparent and LCDC.1 is enabled, the OAM pixel's priority is compared. If LCDC.0 is disabled, the BG pixel color is forced to 0 (DMG) or loses priority (CGB). Final color is looked up from the appropriate palette register.