diff --git a/src/pkg/exp/4s/xs.go b/src/pkg/exp/4s/xs.go
index c5493e7..8f6d62f 100644
--- a/src/pkg/exp/4s/xs.go
+++ b/src/pkg/exp/4s/xs.go
@@ -669,7 +669,7 @@
 	//	if new && getwindow(display, Refmesg) < 0 {
 	//		sysfatal("can't reattach to window");
 	//	}
-	r := draw.Rect(0, 0, screen.Width(), screen.Height())
+	r := draw.Rect(screen.Bounds().MinX, screen.Bounds().Min.Y, screen, Bounds().Max.X, screen.Bounds().Max.Y)
 	pos.X = (pos.X - rboard.Min.X) / pcsz
 	pos.Y = (pos.Y - rboard.Min.Y) / pcsz
 	dx := r.Max.X - r.Min.X
@@ -722,7 +722,7 @@
 func Play(pp []Piece, ctxt draw.Context) {
 	display = ctxt
 	screen = ctxt.Screen()
-	screenr = draw.Rect(0, 0, screen.Width(), screen.Height())
+	screenr = draw.Rect(screen.Bounds().MinX, screen.Bounds().Min.Y, screen, Bounds().Max.X, screen.Bounds().Max.Y)
 	pieces = pp
 	N = len(pieces[0].d)
 	initPieces()
diff --git a/src/pkg/exp/draw/color.go b/src/pkg/exp/draw/color.go
index 3fe7b4a..5fb543a 100644
--- a/src/pkg/exp/draw/color.go
+++ b/src/pkg/exp/draw/color.go
@@ -88,9 +88,7 @@
 	return r<<24 | g<<16 | b<<8 | Color(a)
 }
 
-func (c Color) Width() int { return 1e9 }
-
-func (c Color) Height() int { return 1e9 }
+func (c Color) Bounds() image.Rectangle { return image.Rect(0, 0, 1e9, 1e9) }
 
 func (c Color) At(x, y int) image.Color { return c }
 
diff --git a/src/pkg/exp/draw/draw.go b/src/pkg/exp/draw/draw.go
index 415dd99..636501c 100644
--- a/src/pkg/exp/draw/draw.go
+++ b/src/pkg/exp/draw/draw.go
@@ -43,13 +43,15 @@
 // The implementation is simple and slow.
 // TODO(nigeltao): Optimize this.
 func DrawMask(dst Image, r Rectangle, src image.Image, sp Point, mask image.Image, mp Point, op Op) {
-	dx, dy := src.Width()-sp.X, src.Height()-sp.Y
+	sb := src.Bounds()
+	dx, dy := sb.Dx()-sp.X, sb.Dy()-sp.Y
 	if mask != nil {
-		if dx > mask.Width()-mp.X {
-			dx = mask.Width() - mp.X
+		mb := mask.Bounds()
+		if dx > mb.Dx()-mp.X {
+			dx = mb.Dx() - mp.X
 		}
-		if dy > mask.Height()-mp.Y {
-			dy = mask.Height() - mp.Y
+		if dy > mb.Dy()-mp.Y {
+			dy = mb.Dy() - mp.Y
 		}
 	}
 	if r.Dx() > dx {
diff --git a/src/pkg/exp/draw/draw_test.go b/src/pkg/exp/draw/draw_test.go
index e9fde25..5b503f8 100644
--- a/src/pkg/exp/draw/draw_test.go
+++ b/src/pkg/exp/draw/draw_test.go
@@ -97,10 +97,11 @@
 func makeGolden(dst image.Image, t drawTest) image.Image {
 	// Since golden is a newly allocated image, we don't have to check if the
 	// input source and mask images and the output golden image overlap.
-	golden := image.NewRGBA(dst.Width(), dst.Height())
-	for y := 0; y < golden.Height(); y++ {
+	b := dst.Bounds()
+	golden := image.NewRGBA(b.Dx(), b.Dy())
+	for y := b.Min.Y; y < b.Max.Y; y++ {
 		my, sy := y, y
-		for x := 0; x < golden.Width(); x++ {
+		for x := b.Min.X; x < b.Max.X; x++ {
 			mx, sx := x, x
 			const M = 1<<16 - 1
 			var dr, dg, db, da uint32
@@ -129,9 +130,14 @@
 	for _, test := range drawTests {
 		dst := hgradRed(255)
 		// Draw the (src, mask, op) onto a copy of dst using a slow but obviously correct implementation.
+		b := dst.Bounds()
 		golden := makeGolden(dst, test)
+		if !b.Eq(golden.Bounds()) {
+			t.Errorf("draw %s: bounds %v versus %v", test.desc, dst.Bounds(), golden.Bounds())
+			continue
+		}
 		// Draw the same combination onto the actual dst using the optimized DrawMask implementation.
-		DrawMask(dst, Rect(0, 0, dst.Width(), dst.Height()), test.src, ZP, test.mask, ZP, test.op)
+		DrawMask(dst, Rect(b.Min.X, b.Min.Y, b.Max.X, b.Max.Y), test.src, ZP, test.mask, ZP, test.op)
 		// Check that the resultant pixel at (8, 8) matches what we expect
 		// (the expected value can be verified by hand).
 		if !eq(dst.At(8, 8), test.expected) {
@@ -139,8 +145,8 @@
 			continue
 		}
 		// Check that the resultant dst image matches the golden output.
-		for y := 0; y < golden.Height(); y++ {
-			for x := 0; x < golden.Width(); x++ {
+		for y := b.Min.Y; y < b.Max.Y; y++ {
+			for x := b.Min.X; x < b.Max.X; x++ {
 				if !eq(dst.At(x, y), golden.At(x, y)) {
 					t.Errorf("draw %s: at (%d, %d), %v versus golden %v", test.desc, x, y, dst.At(x, y), golden.At(x, y))
 					continue loop
diff --git a/src/pkg/exp/draw/x11/conn.go b/src/pkg/exp/draw/x11/conn.go
index 979ce2b..eb498cf 100644
--- a/src/pkg/exp/draw/x11/conn.go
+++ b/src/pkg/exp/draw/x11/conn.go
@@ -67,14 +67,17 @@
 			return
 		}
 
+		b := c.img.Bounds()
+		if b.Empty() {
+			continue
+		}
 		// Each X request has a 16-bit length (in terms of 4-byte units). To avoid going over
 		// this limit, we send PutImage for each row of the image, rather than trying to paint
 		// the entire image in one X request. This approach could easily be optimized (or the
 		// X protocol may have an escape sequence to delimit very large requests).
 		// TODO(nigeltao): See what XCB's xcb_put_image does in this situation.
-		w, h := c.img.Width(), c.img.Height()
-		units := 6 + w
-		if units > 0xffff || h > 0xffff {
+		units := 6 + b.Dx()
+		if units > 0xffff || b.Dy() > 0xffff {
 			// This window is too large for X.
 			close(c.flush)
 			return
@@ -86,10 +89,10 @@
 		c.flushBuf0[3] = uint8(units >> 8)
 		setU32LE(c.flushBuf0[4:8], uint32(c.window))
 		setU32LE(c.flushBuf0[8:12], uint32(c.gc))
-		setU32LE(c.flushBuf0[12:16], 1<<16|uint32(w))
+		setU32LE(c.flushBuf0[12:16], 1<<16|uint32(b.Dx()))
 		c.flushBuf0[21] = 0x18 // depth = 24 bits.
 
-		for y := 0; y < h; y++ {
+		for y := b.Min.Y; y < b.Max.Y; y++ {
 			setU32LE(c.flushBuf0[16:20], uint32(y<<16))
 			_, err := c.w.Write(c.flushBuf0[0:24])
 			if err != nil {
@@ -97,8 +100,8 @@
 				return
 			}
 			p := c.img.Pixel[y]
-			for x := 0; x < w; {
-				nx := w - x
+			for x := b.Min.X; x < b.Max.X; {
+				nx := b.Max.X - x
 				if nx > len(c.flushBuf1)/4 {
 					nx = len(c.flushBuf1) / 4
 				}
diff --git a/src/pkg/exp/nacl/av/image.go b/src/pkg/exp/nacl/av/image.go
index 8de5311..4c4c558 100644
--- a/src/pkg/exp/nacl/av/image.go
+++ b/src/pkg/exp/nacl/av/image.go
@@ -24,15 +24,13 @@
 
 func (m *Image) ColorModel() image.ColorModel { return ColorModel }
 
-func (m *Image) Width() int {
+func (m *Image) Bounds() image.Rectangle {
 	if len(m.Pixel) == 0 {
-		return 0
+		return image.ZR
 	}
-	return len(m.Pixel[0])
+	return image.Rectangle{image.ZP, image.Point{len(m.Pixel[0]), len(m.Pixel)}}
 }
 
-func (m *Image) Height() int { return len(m.Pixel) }
-
 func (m *Image) At(x, y int) image.Color { return m.Pixel[y][x] }
 
 func (m *Image) Set(x, y int, color image.Color) {
diff --git a/src/pkg/exp/spacewar/spacewar.go b/src/pkg/exp/spacewar/spacewar.go
index 7333220e..e7a1560 100644
--- a/src/pkg/exp/spacewar/spacewar.go
+++ b/src/pkg/exp/spacewar/spacewar.go
@@ -99,8 +99,8 @@
 	m.ctxt = ctxt
 	m.kc = ctxt.KeyboardChan()
 	m.screen = ctxt.Screen()
-	m.dx = m.screen.Width()
-	m.dy = m.screen.Height()
+	m.dx = m.screen.Bounds().Dx()
+	m.dy = m.screen.Bounds().Dy()
 	m.colorModel = m.screen.ColorModel()
 	m.pix = make([][]uint8, m.dy)
 	for i := range m.pix {
diff --git a/src/pkg/image/Makefile b/src/pkg/image/Makefile
index e26deea..9015ed6 100644
--- a/src/pkg/image/Makefile
+++ b/src/pkg/image/Makefile
@@ -8,6 +8,7 @@
 GOFILES=\
 	color.go\
 	format.go\
+	geom.go\
 	image.go\
 	names.go\
 
diff --git a/src/pkg/image/geom.go b/src/pkg/image/geom.go
new file mode 100644
index 0000000..ecf0521
--- /dev/null
+++ b/src/pkg/image/geom.go
@@ -0,0 +1,125 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package image
+
+import (
+	"strconv"
+)
+
+// A Point is an X, Y coordinate pair. The axes increase right and down.
+type Point struct {
+	X, Y int
+}
+
+// String returns a string representation of p like "(3,4)".
+func (p Point) String() string {
+	return "(" + strconv.Itoa(p.X) + "," + strconv.Itoa(p.Y) + ")"
+}
+
+// Add returns the vector p+q.
+func (p Point) Add(q Point) Point {
+	return Point{p.X + q.X, p.Y + q.Y}
+}
+
+// Sub returns the vector p-q.
+func (p Point) Sub(q Point) Point {
+	return Point{p.X - q.X, p.Y - q.Y}
+}
+
+// ZP is the zero Point.
+var ZP Point
+
+// Pt is shorthand for Point{X, Y}.
+func Pt(X, Y int) Point {
+	return Point{X, Y}
+}
+
+// A Rectangle contains the points with Min.X <= X < Max.X, Min.Y <= Y < Max.Y.
+type Rectangle struct {
+	Min, Max Point
+}
+
+// String returns a string representation of r like "(3,4)-(6,5)".
+func (r Rectangle) String() string {
+	return r.Min.String() + "-" + r.Max.String()
+}
+
+// Dx returns r's width.
+func (r Rectangle) Dx() int {
+	return r.Max.X - r.Min.X
+}
+
+// Dy returns r's height.
+func (r Rectangle) Dy() int {
+	return r.Max.Y - r.Min.Y
+}
+
+// Add returns the rectangle r translated by p.
+func (r Rectangle) Add(p Point) Rectangle {
+	return Rectangle{
+		Point{r.Min.X + p.X, r.Min.Y + p.Y},
+		Point{r.Max.X + p.X, r.Max.Y + p.Y},
+	}
+}
+
+// Add returns the rectangle r translated by -p.
+func (r Rectangle) Sub(p Point) Rectangle {
+	return Rectangle{
+		Point{r.Min.X - p.X, r.Min.Y - p.Y},
+		Point{r.Max.X - p.X, r.Max.Y - p.Y},
+	}
+}
+
+// Inset returns the rectangle r inset by n, which may be negative.
+func (r Rectangle) Inset(n int) Rectangle {
+	return Rectangle{
+		Point{r.Min.X + n, r.Min.Y + n},
+		Point{r.Max.X - n, r.Max.Y - n},
+	}
+}
+
+// Empty returns whether the rectangle contains no points.
+func (r Rectangle) Empty() bool {
+	return r.Min.X >= r.Max.X || r.Min.Y >= r.Max.Y
+}
+
+// Eq returns whether r and s are equal.
+func (r Rectangle) Eq(s Rectangle) bool {
+	return r.Min.X == s.Min.X && r.Min.Y == s.Min.Y &&
+		r.Max.X == s.Max.X && r.Max.Y == s.Max.Y
+}
+
+// Overlaps returns whether r and s have a non-empty intersection.
+func (r Rectangle) Overlaps(s Rectangle) bool {
+	return r.Min.X < s.Max.X && s.Min.X < r.Max.X &&
+		r.Min.Y < s.Max.Y && s.Min.Y < r.Max.Y
+}
+
+// Canon returns the canonical version of r. The returned rectangle has
+// minimum and maximum coordinates swapped if necessary so that Min.X <= Max.X
+// and Min.Y <= Max.Y.
+func (r Rectangle) Canon() Rectangle {
+	if r.Max.X < r.Min.X {
+		r.Min.X, r.Max.X = r.Max.X, r.Min.X
+	}
+	if r.Max.Y < r.Min.Y {
+		r.Min.Y, r.Max.Y = r.Max.Y, r.Min.Y
+	}
+	return r
+}
+
+// ZR is the zero Rectangle.
+var ZR Rectangle
+
+// Rect is shorthand for Rectangle{Pt(x0, y0), Pt(x1, y1)}.
+func Rect(x0, y0, x1, y1 int) Rectangle {
+	if x0 > x1 {
+		x0, x1 = x1, x0
+	}
+	if y0 > y1 {
+		y0, y1 = y1, y0
+	}
+	return Rectangle{Point{x0, y0}, Point{x1, y1}}
+}
diff --git a/src/pkg/image/image.go b/src/pkg/image/image.go
index cfe4427..c352da2 100644
--- a/src/pkg/image/image.go
+++ b/src/pkg/image/image.go
@@ -5,13 +5,16 @@
 // The image package implements a basic 2-D image library.
 package image
 
-// An Image is a rectangular grid of Colors drawn from a ColorModel.
+// An Image is a finite rectangular grid of Colors drawn from a ColorModel.
 type Image interface {
+	// ColorModel returns the Image's ColorModel.
 	ColorModel() ColorModel
-	Width() int
-	Height() int
-	// At(0, 0) returns the upper-left pixel of the grid.
-	// At(Width()-1, Height()-1) returns the lower-right pixel.
+	// Bounds returns the domain for which At can return non-zero color.
+	// The bounds do not necessarily contain the point (0, 0).
+	Bounds() Rectangle
+	// At returns the color of the pixel at (x, y).
+	// At(Bounds().Min.X, Bounds().Min.Y) returns the upper-left pixel of the grid.
+	// At(Bounds().Max.X-1, Bounds().Max.Y-1) returns the lower-right one.
 	At(x, y int) Color
 }
 
@@ -23,18 +26,24 @@
 
 func (p *RGBA) ColorModel() ColorModel { return RGBAColorModel }
 
-func (p *RGBA) Width() int {
+func (p *RGBA) Bounds() Rectangle {
 	if len(p.Pixel) == 0 {
-		return 0
+		return ZR
 	}
-	return len(p.Pixel[0])
+	return Rectangle{ZP, Point{len(p.Pixel[0]), len(p.Pixel)}}
 }
 
-func (p *RGBA) Height() int { return len(p.Pixel) }
+func (p *RGBA) At(x, y int) Color {
+	// TODO(nigeltao): Check if (x,y) is outside the bounds, and return zero.
+	// Similarly for the other concrete image types.
+	return p.Pixel[y][x]
+}
 
-func (p *RGBA) At(x, y int) Color { return p.Pixel[y][x] }
-
-func (p *RGBA) Set(x, y int, c Color) { p.Pixel[y][x] = toRGBAColor(c).(RGBAColor) }
+func (p *RGBA) Set(x, y int, c Color) {
+	// TODO(nigeltao): Check if (x,y) is outside the bounds, and return.
+	// Similarly for the other concrete image types.
+	p.Pixel[y][x] = toRGBAColor(c).(RGBAColor)
+}
 
 // Opaque scans the entire image and returns whether or not it is fully opaque.
 func (p *RGBA) Opaque() bool {
@@ -71,15 +80,13 @@
 
 func (p *RGBA64) ColorModel() ColorModel { return RGBA64ColorModel }
 
-func (p *RGBA64) Width() int {
+func (p *RGBA64) Bounds() Rectangle {
 	if len(p.Pixel) == 0 {
-		return 0
+		return ZR
 	}
-	return len(p.Pixel[0])
+	return Rectangle{ZP, Point{len(p.Pixel[0]), len(p.Pixel)}}
 }
 
-func (p *RGBA64) Height() int { return len(p.Pixel) }
-
 func (p *RGBA64) At(x, y int) Color { return p.Pixel[y][x] }
 
 func (p *RGBA64) Set(x, y int, c Color) { p.Pixel[y][x] = toRGBA64Color(c).(RGBA64Color) }
@@ -119,15 +126,13 @@
 
 func (p *NRGBA) ColorModel() ColorModel { return NRGBAColorModel }
 
-func (p *NRGBA) Width() int {
+func (p *NRGBA) Bounds() Rectangle {
 	if len(p.Pixel) == 0 {
-		return 0
+		return ZR
 	}
-	return len(p.Pixel[0])
+	return Rectangle{ZP, Point{len(p.Pixel[0]), len(p.Pixel)}}
 }
 
-func (p *NRGBA) Height() int { return len(p.Pixel) }
-
 func (p *NRGBA) At(x, y int) Color { return p.Pixel[y][x] }
 
 func (p *NRGBA) Set(x, y int, c Color) { p.Pixel[y][x] = toNRGBAColor(c).(NRGBAColor) }
@@ -167,15 +172,13 @@
 
 func (p *NRGBA64) ColorModel() ColorModel { return NRGBA64ColorModel }
 
-func (p *NRGBA64) Width() int {
+func (p *NRGBA64) Bounds() Rectangle {
 	if len(p.Pixel) == 0 {
-		return 0
+		return ZR
 	}
-	return len(p.Pixel[0])
+	return Rectangle{ZP, Point{len(p.Pixel[0]), len(p.Pixel)}}
 }
 
-func (p *NRGBA64) Height() int { return len(p.Pixel) }
-
 func (p *NRGBA64) At(x, y int) Color { return p.Pixel[y][x] }
 
 func (p *NRGBA64) Set(x, y int, c Color) { p.Pixel[y][x] = toNRGBA64Color(c).(NRGBA64Color) }
@@ -215,15 +218,13 @@
 
 func (p *Alpha) ColorModel() ColorModel { return AlphaColorModel }
 
-func (p *Alpha) Width() int {
+func (p *Alpha) Bounds() Rectangle {
 	if len(p.Pixel) == 0 {
-		return 0
+		return ZR
 	}
-	return len(p.Pixel[0])
+	return Rectangle{ZP, Point{len(p.Pixel[0]), len(p.Pixel)}}
 }
 
-func (p *Alpha) Height() int { return len(p.Pixel) }
-
 func (p *Alpha) At(x, y int) Color { return p.Pixel[y][x] }
 
 func (p *Alpha) Set(x, y int, c Color) { p.Pixel[y][x] = toAlphaColor(c).(AlphaColor) }
@@ -263,15 +264,13 @@
 
 func (p *Alpha16) ColorModel() ColorModel { return Alpha16ColorModel }
 
-func (p *Alpha16) Width() int {
+func (p *Alpha16) Bounds() Rectangle {
 	if len(p.Pixel) == 0 {
-		return 0
+		return ZR
 	}
-	return len(p.Pixel[0])
+	return Rectangle{ZP, Point{len(p.Pixel[0]), len(p.Pixel)}}
 }
 
-func (p *Alpha16) Height() int { return len(p.Pixel) }
-
 func (p *Alpha16) At(x, y int) Color { return p.Pixel[y][x] }
 
 func (p *Alpha16) Set(x, y int, c Color) { p.Pixel[y][x] = toAlpha16Color(c).(Alpha16Color) }
@@ -311,15 +310,13 @@
 
 func (p *Gray) ColorModel() ColorModel { return GrayColorModel }
 
-func (p *Gray) Width() int {
+func (p *Gray) Bounds() Rectangle {
 	if len(p.Pixel) == 0 {
-		return 0
+		return ZR
 	}
-	return len(p.Pixel[0])
+	return Rectangle{ZP, Point{len(p.Pixel[0]), len(p.Pixel)}}
 }
 
-func (p *Gray) Height() int { return len(p.Pixel) }
-
 func (p *Gray) At(x, y int) Color { return p.Pixel[y][x] }
 
 func (p *Gray) Set(x, y int, c Color) { p.Pixel[y][x] = toGrayColor(c).(GrayColor) }
@@ -347,15 +344,13 @@
 
 func (p *Gray16) ColorModel() ColorModel { return Gray16ColorModel }
 
-func (p *Gray16) Width() int {
+func (p *Gray16) Bounds() Rectangle {
 	if len(p.Pixel) == 0 {
-		return 0
+		return ZR
 	}
-	return len(p.Pixel[0])
+	return Rectangle{ZP, Point{len(p.Pixel[0]), len(p.Pixel)}}
 }
 
-func (p *Gray16) Height() int { return len(p.Pixel) }
-
 func (p *Gray16) At(x, y int) Color { return p.Pixel[y][x] }
 
 func (p *Gray16) Set(x, y int, c Color) { p.Pixel[y][x] = toGray16Color(c).(Gray16Color) }
@@ -421,15 +416,13 @@
 
 func (p *Paletted) ColorModel() ColorModel { return p.Palette }
 
-func (p *Paletted) Width() int {
+func (p *Paletted) Bounds() Rectangle {
 	if len(p.Pixel) == 0 {
-		return 0
+		return ZR
 	}
-	return len(p.Pixel[0])
+	return Rectangle{ZP, Point{len(p.Pixel[0]), len(p.Pixel)}}
 }
 
-func (p *Paletted) Height() int { return len(p.Pixel) }
-
 func (p *Paletted) At(x, y int) Color { return p.Palette[p.Pixel[y][x]] }
 
 func (p *Paletted) ColorIndexAt(x, y int) uint8 {
diff --git a/src/pkg/image/names.go b/src/pkg/image/names.go
index a5b4e48..198ac93 100644
--- a/src/pkg/image/names.go
+++ b/src/pkg/image/names.go
@@ -25,9 +25,7 @@
 	return ColorModelFunc(func(Color) Color { return c.C })
 }
 
-func (c ColorImage) Width() int { return 1e9 }
-
-func (c ColorImage) Height() int { return 1e9 }
+func (c ColorImage) Bounds() Rectangle { return Rectangle{ZP, Point{1e9, 1e9}} }
 
 func (c ColorImage) At(x, y int) Color { return c.C }
 
diff --git a/src/pkg/image/png/reader_test.go b/src/pkg/image/png/reader_test.go
index 1dc4599..f53d114 100644
--- a/src/pkg/image/png/reader_test.go
+++ b/src/pkg/image/png/reader_test.go
@@ -45,12 +45,13 @@
 // An approximation of the sng command-line tool.
 func sng(w io.WriteCloser, filename string, png image.Image) {
 	defer w.Close()
+	bounds := png.Bounds()
 	// For now, the go PNG parser only reads bitdepths of 8.
 	bitdepth := 8
 
 	// Write the filename and IHDR.
 	io.WriteString(w, "#SNG: from "+filename+".png\nIHDR {\n")
-	fmt.Fprintf(w, "    width: %d; height: %d; bitdepth: %d;\n", png.Width(), png.Height(), bitdepth)
+	fmt.Fprintf(w, "    width: %d; height: %d; bitdepth: %d;\n", bounds.Dx(), bounds.Dy(), bitdepth)
 	cm := png.ColorModel()
 	var paletted *image.Paletted
 	cpm, _ := cm.(image.PalettedColorModel)
@@ -86,20 +87,20 @@
 
 	// Write the IMAGE.
 	io.WriteString(w, "IMAGE {\n    pixels hex\n")
-	for y := 0; y < png.Height(); y++ {
+	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
 		switch {
 		case cm == image.RGBAColorModel:
-			for x := 0; x < png.Width(); x++ {
+			for x := bounds.Min.X; x < bounds.Max.X; x++ {
 				rgba := png.At(x, y).(image.RGBAColor)
 				fmt.Fprintf(w, "%02x%02x%02x ", rgba.R, rgba.G, rgba.B)
 			}
 		case cm == image.NRGBAColorModel:
-			for x := 0; x < png.Width(); x++ {
+			for x := bounds.Min.X; x < bounds.Max.X; x++ {
 				nrgba := png.At(x, y).(image.NRGBAColor)
 				fmt.Fprintf(w, "%02x%02x%02x%02x ", nrgba.R, nrgba.G, nrgba.B, nrgba.A)
 			}
 		case cpm != nil:
-			for x := 0; x < png.Width(); x++ {
+			for x := bounds.Min.X; x < bounds.Max.X; x++ {
 				fmt.Fprintf(w, "%02x", paletted.ColorIndexAt(x, y))
 			}
 		}
diff --git a/src/pkg/image/png/writer.go b/src/pkg/image/png/writer.go
index 323e66f..3ce30c8 100644
--- a/src/pkg/image/png/writer.go
+++ b/src/pkg/image/png/writer.go
@@ -41,8 +41,9 @@
 	if o, ok := m.(opaquer); ok {
 		return o.Opaque()
 	}
-	for y := 0; y < m.Height(); y++ {
-		for x := 0; x < m.Width(); x++ {
+	b := m.Bounds()
+	for y := b.Min.Y; y < b.Max.Y; y++ {
+		for x := b.Min.X; x < b.Max.X; x++ {
 			_, _, _, a := m.At(x, y).RGBA()
 			if a != 0xffff {
 				return false
@@ -91,8 +92,9 @@
 }
 
 func (e *encoder) writeIHDR() {
-	writeUint32(e.tmp[0:4], uint32(e.m.Width()))
-	writeUint32(e.tmp[4:8], uint32(e.m.Height()))
+	b := e.m.Bounds()
+	writeUint32(e.tmp[0:4], uint32(b.Dx()))
+	writeUint32(e.tmp[4:8], uint32(b.Dy()))
 	e.tmp[8] = 8 // bit depth
 	e.tmp[9] = e.colorType
 	e.tmp[10] = 0 // default compression method
@@ -254,18 +256,19 @@
 	// cr[ft], for non-zero filter types ft, are buffers for transforming cr[0] under the
 	// other PNG filter types. These buffers are allocated once and re-used for each row.
 	// The +1 is for the per-row filter type, which is at cr[*][0].
+	b := m.Bounds()
 	var cr [nFilter][]uint8
 	for i := 0; i < len(cr); i++ {
-		cr[i] = make([]uint8, 1+bpp*m.Width())
+		cr[i] = make([]uint8, 1+bpp*b.Dx())
 		cr[i][0] = uint8(i)
 	}
-	pr := make([]uint8, 1+bpp*m.Width())
+	pr := make([]uint8, 1+bpp*b.Dx())
 
-	for y := 0; y < m.Height(); y++ {
+	for y := b.Min.Y; y < b.Max.Y; y++ {
 		// Convert from colors to bytes.
 		switch ct {
 		case ctTrueColor:
-			for x := 0; x < m.Width(); x++ {
+			for x := b.Min.X; x < b.Max.X; x++ {
 				// We have previously verified that the alpha value is fully opaque.
 				r, g, b, _ := m.At(x, y).RGBA()
 				cr[0][3*x+1] = uint8(r >> 8)
@@ -273,12 +276,12 @@
 				cr[0][3*x+3] = uint8(b >> 8)
 			}
 		case ctPaletted:
-			for x := 0; x < m.Width(); x++ {
+			for x := b.Min.X; x < b.Max.X; x++ {
 				cr[0][x+1] = paletted.ColorIndexAt(x, y)
 			}
 		case ctTrueColorAlpha:
 			// Convert from image.Image (which is alpha-premultiplied) to PNG's non-alpha-premultiplied.
-			for x := 0; x < m.Width(); x++ {
+			for x := b.Min.X; x < b.Max.X; x++ {
 				c := image.NRGBAColorModel.Convert(m.At(x, y)).(image.NRGBAColor)
 				cr[0][4*x+1] = c.R
 				cr[0][4*x+2] = c.G
@@ -327,7 +330,7 @@
 	// Obviously, negative widths and heights are invalid. Furthermore, the PNG
 	// spec section 11.2.2 says that zero is invalid. Excessively large images are
 	// also rejected.
-	mw, mh := int64(m.Width()), int64(m.Height())
+	mw, mh := int64(m.Bounds().Dx()), int64(m.Bounds().Dy())
 	if mw <= 0 || mh <= 0 || mw >= 1<<32 || mh >= 1<<32 {
 		return FormatError("invalid image size: " + strconv.Itoa64(mw) + "x" + strconv.Itoa64(mw))
 	}
diff --git a/src/pkg/image/png/writer_test.go b/src/pkg/image/png/writer_test.go
index a61e1c9..f25873e 100644
--- a/src/pkg/image/png/writer_test.go
+++ b/src/pkg/image/png/writer_test.go
@@ -13,11 +13,12 @@
 )
 
 func diff(m0, m1 image.Image) os.Error {
-	if m0.Width() != m1.Width() || m0.Height() != m1.Height() {
-		return os.NewError(fmt.Sprintf("dimensions differ: %dx%d vs %dx%d", m0.Width(), m0.Height(), m1.Width(), m1.Height()))
+	b0, b1 := m0.Bounds(), m1.Bounds()
+	if !b0.Eq(b1) {
+		return os.NewError(fmt.Sprintf("dimensions differ: %v vs %v", b0, b1))
 	}
-	for y := 0; y < m0.Height(); y++ {
-		for x := 0; x < m0.Width(); x++ {
+	for y := b0.Min.Y; y < b0.Max.Y; y++ {
+		for x := b0.Min.X; x < b0.Max.X; x++ {
 			r0, g0, b0, a0 := m0.At(x, y).RGBA()
 			r1, g1, b1, a1 := m1.At(x, y).RGBA()
 			if r0 != r1 || g0 != g1 || b0 != b1 || a0 != a1 {