diff --git a/arch/arch.go b/arch/arch.go
index 7a2a65d..441feed 100644
--- a/arch/arch.go
+++ b/arch/arch.go
@@ -41,6 +41,30 @@
 	panic("no IntSize")
 }
 
+func (a *Architecture) Int16(buf []byte) int16 {
+	return int16(a.Uint16(buf))
+}
+
+func (a *Architecture) Int32(buf []byte) int32 {
+	return int32(a.Uint32(buf))
+}
+
+func (a *Architecture) Int64(buf []byte) int64 {
+	return int64(a.Uint64(buf))
+}
+
+func (a *Architecture) Uint16(buf []byte) uint16 {
+	return a.ByteOrder.Uint16(buf)
+}
+
+func (a *Architecture) Uint32(buf []byte) uint32 {
+	return a.ByteOrder.Uint32(buf)
+}
+
+func (a *Architecture) Uint64(buf []byte) uint64 {
+	return a.ByteOrder.Uint64(buf)
+}
+
 func (a *Architecture) IntN(buf []byte) int64 {
 	return int64(a.UintN(buf))
 }
diff --git a/program/server/print.go b/program/server/print.go
index ef458db..7a11262 100644
--- a/program/server/print.go
+++ b/program/server/print.go
@@ -282,7 +282,17 @@
 	p.printf("}")
 }
 
-// TODO: Unimplemented.
+// mapDesc collects the information necessary to print a map.
+type mapDesc struct {
+	typ        *dwarf.MapType
+	count      int
+	numBuckets int
+	keySize    uintptr
+	elemSize   uintptr
+	bucketSize uintptr
+	buf        []byte
+}
+
 func (p *Printer) printMapAt(typ *dwarf.MapType, addr uintptr) {
 	// Maps are pointers to a struct type.
 	structType := typ.Type.(*dwarf.PtrType).Type.(*dwarf.StructType)
@@ -295,11 +305,82 @@
 	if !p.peek(addr, structType.ByteSize) {
 		return
 	}
-	// TODO: unimplemented. Hard.
-	countField := structType.Field[0]
-	p.printf("%s with ", typ)
-	p.printValueAt(countField.Type, addr+uintptr(countField.ByteOffset))
-	p.printf(" elements")
+	// From runtime/hashmap.*; We need to walk the map data structure.
+	// Load the struct, then iterate over the buckets.
+	// uintgo count (occupancy).
+	offset := int(structType.Field[0].ByteOffset)
+	count := int(p.arch.Uint(p.tmp[offset : offset+p.arch.IntSize]))
+	// uint8 Log2 of number of buckets.
+	b := uint(p.tmp[structType.Field[3].ByteOffset])
+	// uint8 key size in bytes.
+	keySize := uintptr(p.tmp[structType.Field[4].ByteOffset])
+	// uint8 element size in bytes.
+	elemSize := uintptr(p.tmp[structType.Field[5].ByteOffset])
+	// uint16 bucket size in bytes.
+	bucketSize := uintptr(p.arch.Uint16(p.tmp[structType.Field[6].ByteOffset:]))
+	// pointer to buckets
+	offset = int(structType.Field[7].ByteOffset)
+	bucketPtr := uintptr(p.arch.Uintptr(p.tmp[offset : offset+p.arch.PointerSize]))
+	// pointer to old buckets.
+	offset = int(structType.Field[8].ByteOffset)
+	oldBucketPtr := uintptr(p.arch.Uintptr(p.tmp[offset : offset+p.arch.PointerSize]))
+	// Ready to print.
+	p.printf("%s{", typ)
+	desc := mapDesc{
+		typ:        typ,
+		count:      count,
+		numBuckets: 1 << b,
+		keySize:    keySize,
+		elemSize:   elemSize,
+		bucketSize: bucketSize,
+		buf:        make([]byte, bucketSize),
+	}
+	p.printMapBucketsAt(desc, bucketPtr)
+	p.printMapBucketsAt(desc, oldBucketPtr)
+	p.printf("}")
+}
+
+// Map bucket layout from runtime/hashmap.*
+const (
+	bucketCnt  = 8 // BUCKETSIZE (poor name) in C code.
+	minTopHash = 4
+)
+
+func (p *Printer) printMapBucketsAt(desc mapDesc, addr uintptr) {
+	if addr == 0 {
+		return
+	}
+	for i := 0; desc.count > 0 && i < desc.numBuckets; i++ {
+		// Load this bucket struct into memory and initialize "pointers" to the key and value slices.
+		// After the header, the bucket struct has an array of keys followed by an array of elements.
+		if !p.ok(p.peeker.peek(addr, desc.buf)) {
+			return
+		}
+		// TODO: We have loaded the data but printValueAt loads from remote addresses
+		// so we need to keep track of addresses and read memory twice. It would
+		// be nice to avoid this overhead.
+		keyAddr := addr + bucketCnt + uintptr(p.arch.PointerSize)
+		elemAddr := keyAddr + bucketCnt*desc.keySize
+		addr += desc.bucketSize // Advance to next bucket; buf, keyAddr and elemAddr are all we need now.
+		// tophash uint8 [bucketCnt] tells us which buckets are occupied.
+		tophash := desc.buf[:bucketCnt]
+		for j := 0; desc.count > 0 && j < bucketCnt; j++ {
+			if tophash[j] >= minTopHash {
+				p.printValueAt(desc.typ.KeyType, keyAddr)
+				p.printf(":")
+				p.printValueAt(desc.typ.ElemType, elemAddr)
+				desc.count--
+				if desc.count > 0 {
+					p.printf(", ")
+				}
+			}
+			keyAddr += desc.keySize
+			elemAddr += desc.elemSize
+		}
+		// pointer to overflow bucket, if any.
+		overflow := uintptr(p.arch.Uintptr(desc.buf[bucketCnt : bucketCnt+p.arch.PointerSize]))
+		p.printMapBucketsAt(desc, overflow)
+	}
 }
 
 func (p *Printer) printSliceAt(typ *dwarf.SliceType, addr uintptr) {