diff --git a/ogle/demo/ogler/ogler_test.go b/ogle/demo/ogler/ogler_test.go
index 6231783..f3640b6 100644
--- a/ogle/demo/ogler/ogler_test.go
+++ b/ogle/demo/ogler/ogler_test.go
@@ -19,14 +19,20 @@
 )
 
 var expectedVarValues = map[string]interface{}{
-	`main.Z_int16`:  int16(-32321),
-	`main.Z_int32`:  int32(-1987654321),
-	`main.Z_int64`:  int64(-9012345678987654321),
-	`main.Z_int8`:   int8(-121),
-	`main.Z_uint16`: uint16(54321),
-	`main.Z_uint32`: uint32(3217654321),
-	`main.Z_uint64`: uint64(12345678900987654321),
-	`main.Z_uint8`:  uint8(231),
+	`main.Z_bool_false`: false,
+	`main.Z_bool_true`:  true,
+	`main.Z_complex128`: complex128(1.987654321 - 2.987654321i),
+	`main.Z_complex64`:  complex64(1.54321 + 2.54321i),
+	`main.Z_float32`:    float32(1.54321),
+	`main.Z_float64`:    float64(1.987654321),
+	`main.Z_int16`:      int16(-32321),
+	`main.Z_int32`:      int32(-1987654321),
+	`main.Z_int64`:      int64(-9012345678987654321),
+	`main.Z_int8`:       int8(-121),
+	`main.Z_uint16`:     uint16(54321),
+	`main.Z_uint32`:     uint32(3217654321),
+	`main.Z_uint64`:     uint64(12345678900987654321),
+	`main.Z_uint8`:      uint8(231),
 }
 
 var expectedVars = map[string]string{
@@ -269,4 +275,75 @@
 			t.Error("Value of invalid location: expected error")
 		}
 	}
+
+	// checkValue tests that we can get a Var for a variable with the given name,
+	// that we can then get the value of that Var, and that calling fn for that
+	// value succeeds.
+	checkValue := func(name string, fn func(val program.Value) error) {
+		if v, err := prog.VarByName(name); err != nil {
+			t.Errorf("VarByName(%s): %s", name, err)
+		} else if val, err := prog.Value(v); err != nil {
+			t.Errorf("value for %s: %s", name, err)
+		} else if err := fn(val); err != nil {
+			t.Errorf("value for %s: %s", name, err)
+		}
+	}
+
+	checkValue("main.Z_uintptr", func(val program.Value) error {
+		if val != uint32(21) && val != uint64(21) {
+			// Z_uintptr should be an unsigned integer with size equal to the debugged
+			// program's address size.
+			return fmt.Errorf("got %T(%v) want 21", val, val)
+		}
+		return nil
+	})
+
+	checkValue("main.Z_int", func(val program.Value) error {
+		if val != int32(-21) && val != int64(-21) {
+			return fmt.Errorf("got %T(%v) want -21", val, val)
+		}
+		return nil
+	})
+
+	checkValue("main.Z_uint", func(val program.Value) error {
+		if val != uint32(21) && val != uint64(21) {
+			return fmt.Errorf("got %T(%v) want 21", val, val)
+		}
+		return nil
+	})
+
+	checkValue("main.Z_pointer", func(val program.Value) error {
+		if _, ok := val.(program.Pointer); !ok {
+			return fmt.Errorf("got %T(%v) expected Pointer", val, val)
+		}
+		return nil
+	})
+
+	checkValue("main.Z_pointer_nil", func(val program.Value) error {
+		if p, ok := val.(program.Pointer); !ok {
+			return fmt.Errorf("got %T(%v) expected Pointer", val, val)
+		} else if p.Address != 0 {
+			return fmt.Errorf("got %T(%v) expected nil pointer", val, val)
+		}
+		return nil
+	})
+
+	checkValue("main.Z_array", func(val program.Value) error {
+		a, ok := val.(program.Array)
+		if !ok {
+			return fmt.Errorf("got %T(%v) expected Array", val, val)
+		}
+		if a.Len() != 5 {
+			return fmt.Errorf("got array length %d expected 5", a.Len())
+		}
+		expected := [5]int8{-121, 121, 3, 2, 1}
+		for i := uint64(0); i < 5; i++ {
+			if v, err := prog.Value(a.Element(i)); err != nil {
+				return fmt.Errorf("reading element %d: %s", i, err)
+			} else if v != expected[i] {
+				return fmt.Errorf("element %d: got %T(%v) want %T(%d)", i, v, v, expected[i], expected[i])
+			}
+		}
+		return nil
+	})
 }
diff --git a/ogle/program/program.go b/ogle/program/program.go
index 9b83dc0..fc86f46 100644
--- a/ogle/program/program.go
+++ b/ogle/program/program.go
@@ -105,6 +105,41 @@
 // A value read from a remote program.
 type Value interface{}
 
+// Pointer is a Var representing a pointer.
+type Pointer Var
+
+// Array is a Var representing an array.
+type Array struct {
+	ElementTypeID uint64
+	Address       uint64
+	Length        uint64 // Number of elements in the array
+	StrideBits    uint64 // Number of bits between array entries
+}
+
+// Len returns the number of elements in the array.
+func (a Array) Len() uint64 {
+	return a.Length
+}
+
+// Element returns a Var referring to the given element of the array.
+func (a Array) Element(index uint64) Var {
+	return Var{
+		TypeID:  a.ElementTypeID,
+		Address: a.Address + index*(a.StrideBits/8),
+	}
+}
+
+// Struct is a Var representing a struct.
+type Struct struct {
+	Fields []StructField
+}
+
+// StructField represents a field in a struct object.
+type StructField struct {
+	Name string
+	Var  Var
+}
+
 // The File interface provides access to file-like resources in the program.
 // It implements only ReaderAt and WriterAt, not Reader and Writer, because
 // random access is a far more common pattern for things like symbol tables,
diff --git a/ogle/program/proxyrpc/proxyrpc.go b/ogle/program/proxyrpc/proxyrpc.go
index e8e8276..18d551f 100644
--- a/ogle/program/proxyrpc/proxyrpc.go
+++ b/ogle/program/proxyrpc/proxyrpc.go
@@ -6,7 +6,18 @@
 // used to the ogleproxy.
 package proxyrpc // import "golang.org/x/debug/ogle/program/proxyrpc"
 
-import "golang.org/x/debug/ogle/program"
+import (
+	"encoding/gob"
+
+	"golang.org/x/debug/ogle/program"
+)
+
+func init() {
+	// Register implementations of program.Var with gob.
+	gob.Register(program.Pointer{})
+	gob.Register(program.Array{})
+	gob.Register(program.Struct{})
+}
 
 // For regularity, each method has a unique Request and a Response type even
 // when not strictly necessary.
diff --git a/ogle/program/server/value.go b/ogle/program/server/value.go
index c273b07..d457b92 100644
--- a/ogle/program/server/value.go
+++ b/ogle/program/server/value.go
@@ -12,10 +12,10 @@
 
 // value peeks the program's memory at the given address, parsing it as a value of type t.
 func (s *Server) value(t dwarf.Type, addr uint64) (program.Value, error) {
-	// readInt reads the memory for an n-byte integer or unsigned integer.
-	readInt := func(n int64) ([]byte, error) {
+	// readBasic reads the memory for a basic type of size n bytes.
+	readBasic := func(n int64) ([]byte, error) {
 		switch n {
-		case 1, 2, 4, 8:
+		case 1, 2, 4, 8, 16:
 		default:
 			return nil, fmt.Errorf("invalid size: %d", n)
 		}
@@ -27,9 +27,9 @@
 	}
 
 	switch t := t.(type) {
-	case *dwarf.IntType:
+	case *dwarf.CharType, *dwarf.IntType:
 		bs := t.Common().ByteSize
-		buf, err := readInt(bs)
+		buf, err := readBasic(bs)
 		if err != nil {
 			return nil, fmt.Errorf("reading integer: %s", err)
 		}
@@ -43,10 +43,12 @@
 			return int32(x), nil
 		case 8:
 			return int64(x), nil
+		default:
+			return nil, fmt.Errorf("invalid integer size: %d", bs)
 		}
-	case *dwarf.UintType:
+	case *dwarf.UcharType, *dwarf.UintType, *dwarf.AddrType:
 		bs := t.Common().ByteSize
-		buf, err := readInt(bs)
+		buf, err := readBasic(bs)
 		if err != nil {
 			return nil, fmt.Errorf("reading unsigned integer: %s", err)
 		}
@@ -60,7 +62,88 @@
 			return uint32(x), nil
 		case 8:
 			return uint64(x), nil
+		default:
+			return nil, fmt.Errorf("invalid unsigned integer size: %d", bs)
 		}
+	case *dwarf.BoolType:
+		bs := t.Common().ByteSize
+		buf, err := readBasic(bs)
+		if err != nil {
+			return nil, fmt.Errorf("reading boolean: %s", err)
+		}
+		for _, b := range buf {
+			if b != 0 {
+				return true, nil
+			}
+		}
+		return false, nil
+	case *dwarf.FloatType:
+		bs := t.Common().ByteSize
+		buf, err := readBasic(bs)
+		if err != nil {
+			return nil, fmt.Errorf("reading float: %s", err)
+		}
+		switch bs {
+		case 4:
+			return s.arch.Float32(buf), nil
+		case 8:
+			return s.arch.Float64(buf), nil
+		default:
+			return nil, fmt.Errorf("invalid float size: %d", bs)
+		}
+	case *dwarf.ComplexType:
+		bs := t.Common().ByteSize
+		buf, err := readBasic(bs)
+		if err != nil {
+			return nil, fmt.Errorf("reading complex: %s", err)
+		}
+		switch bs {
+		case 8:
+			return s.arch.Complex64(buf), nil
+		case 16:
+			return s.arch.Complex128(buf), nil
+		default:
+			return nil, fmt.Errorf("invalid complex size: %d", bs)
+		}
+	case *dwarf.PtrType:
+		bs := t.Common().ByteSize
+		if bs != int64(s.arch.PointerSize) {
+			return nil, fmt.Errorf("invalid pointer size: %d", bs)
+		}
+		buf, err := readBasic(bs)
+		if err != nil {
+			return nil, fmt.Errorf("reading pointer: %s", err)
+		}
+		return program.Pointer{
+			TypeID:  uint64(t.Type.Common().Offset),
+			Address: uint64(s.arch.Uintptr(buf)),
+		}, nil
+	case *dwarf.ArrayType:
+		length := t.Count
+		stride := t.StrideBitSize
+		if stride%8 != 0 {
+			return nil, fmt.Errorf("array is not byte-aligned")
+		}
+		return program.Array{
+			ElementTypeID: uint64(t.Type.Common().Offset),
+			Address:       uint64(addr),
+			Length:        uint64(length),
+			StrideBits:    uint64(stride),
+		}, nil
+	case *dwarf.StructType:
+		fields := make([]program.StructField, len(t.Field))
+		for i, field := range t.Field {
+			fields[i] = program.StructField{
+				Name: field.Name,
+				Var: program.Var{
+					TypeID:  uint64(field.Type.Common().Offset),
+					Address: uint64(addr) + uint64(field.ByteOffset),
+				},
+			}
+		}
+		return program.Struct{fields}, nil
+	case *dwarf.TypedefType:
+		return s.value(t.Type, addr)
 		// TODO: more types
 	}
 	return nil, fmt.Errorf("Unsupported type %T", t)